diff options
author | Drew Fustini <drew@pdp7.com> | 2021-05-21 00:52:32 +0300 |
---|---|---|
committer | GitHub <noreply@github.com> | 2021-05-21 00:52:32 +0300 |
commit | 3f001ea92b4ab9a13c3b6208fcb324e940ec988a (patch) | |
tree | a3faa9d35d5157205d2ffb10d8e9269380a43e00 /drivers/nvdla/include | |
parent | e865a75d55e0e4256242e4405b87c394b5885a57 (diff) | |
parent | 164b9380fd81dff56c70ec4ae2adf7e8986494e0 (diff) | |
download | linux-fedora-vic-7100_5.10.6.tar.xz |
Merge pull request #22 from cybergaszcz/nvdlafedora-vic-7100_5.10.6
Added nvdla driver
Diffstat (limited to 'drivers/nvdla/include')
-rw-r--r-- | drivers/nvdla/include/dla_debug.h | 94 | ||||
-rw-r--r-- | drivers/nvdla/include/dla_engine.h | 94 | ||||
-rw-r--r-- | drivers/nvdla/include/dla_err.h | 50 | ||||
-rw-r--r-- | drivers/nvdla/include/dla_interface.h | 886 | ||||
-rw-r--r-- | drivers/nvdla/include/dla_sched.h | 74 | ||||
-rw-r--r-- | drivers/nvdla/include/nvdla_interface.h | 327 | ||||
-rw-r--r-- | drivers/nvdla/include/nvdla_ioctl.h | 138 | ||||
-rw-r--r-- | drivers/nvdla/include/nvdla_linux.h | 153 | ||||
-rw-r--r-- | drivers/nvdla/include/opendla.h | 48 | ||||
-rw-r--r-- | drivers/nvdla/include/opendla_initial.h | 16743 | ||||
-rw-r--r-- | drivers/nvdla/include/opendla_small.h | 6433 |
11 files changed, 25040 insertions, 0 deletions
diff --git a/drivers/nvdla/include/dla_debug.h b/drivers/nvdla/include/dla_debug.h new file mode 100644 index 000000000000..bef99d620789 --- /dev/null +++ b/drivers/nvdla/include/dla_debug.h @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __FIRMWARE_DLA_DEBUG_H_ +#define __FIRMWARE_DLA_DEBUG_H_ + +#define STRINGIFY(s) #s +#define DEFER_STRINGIFY(s) STRINGIFY(s) +#define FILELINE DEFER_STRINGIFY(__LINE__) +#define FILENAME DEFER_STRINGIFY(__FILE__) + +#define LOG_EVENT_BDMA_SHIFT 0U +#define LOG_EVENT_CONV_SHIFT 4U +#define LOG_EVENT_SDP_SHIFT 8U +#define LOG_EVENT_PDP_SHIFT 12U +#define LOG_EVENT_CDP_SHIFT 16U +#define LOG_EVENT_RBK_SHIFT 20U +#define LOG_EVENT_GROUP_SHIFT 24U +#define LOG_EVENT_ROI_SHIFT 28U + +#define LOG_TASK_START 1 +#define LOG_TASK_END 2 +#define LOG_READ_OP_CONFIG_START 3 +#define LOG_READ_OP_CONFIG_END 4 +#define LOG_READ_SURF_CONFIG_START 5 +#define LOG_READ_SURF_CONFIG_END 6 +#define LOG_PROGRAM_START 7 +#define LOG_PROGRAM_END 8 +#define LOG_OPERATION_START 9 +#define LOG_OPERATION_END 10 + +#define LOG_EVENT(roi, group, processor, event) + +/** + * Used to enable/disable reading stat registers + */ +#define STAT_ENABLE 1 + +/** + * Used to print debug network data + */ +#define DEBUG_NETWORK_DATA 0 + +#define pr_dump_stack(format, ...) +#define dla_trace(format, ...) + +#define assert(condition) + +#define RETURN(err) { return (err); } + +#define DEBUG_ASSERT + +#ifdef DEBUG_ASSERT +#define ASSERT_GOTO(_condition, _ret, _err_value, _goto) \ +do { \ + if (!(_condition)) { \ + dla_error("Assertion Fail(" FILENAME FILELINE "):" \ + STRINGIFY(_condition)); \ + _ret = _err_value; \ + goto _goto; \ + } else { \ + _ret = 0; \ + } \ +} while (0) +#else +#define ASSERT_GOTO(_condition, _ret, _err_value, _goto) assert(condition) +#endif /* DEBUG_ASSERT */ + +#endif diff --git a/drivers/nvdla/include/dla_engine.h b/drivers/nvdla/include/dla_engine.h new file mode 100644 index 000000000000..707adc41d5d4 --- /dev/null +++ b/drivers/nvdla/include/dla_engine.h @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2017-2018, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DLA_ENGINE_H_ +#define __DLA_ENGINE_H_ + +#include <dla_interface.h> +#include <dla_sched.h> + +struct dla_processor_group { + uint8_t id; + uint8_t rdma_id; + uint8_t active; + uint8_t events; + uint8_t roi_index; + uint8_t is_rdma_needed; + uint8_t pending; + int32_t lut_index; + uint8_t programming; + uint64_t start_time; + + struct dla_common_op_desc *op_desc; + struct dla_common_op_desc *consumers[DLA_OP_NUM]; + struct dla_common_op_desc *fused_parent; + union dla_operation_container *operation_desc; + union dla_surface_container *surface_desc; +}; + +struct dla_processor { + const char *name; + uint8_t op_type; + uint8_t consumer_ptr; + uint8_t roi_index; + uint8_t group_status; + uint8_t rdma_status; + uint8_t last_group; + + struct dla_common_op_desc *tail_op; + struct dla_processor_group groups[DLA_NUM_GROUPS]; + union dla_stat_container *stat_data_desc; + + int32_t (*is_ready)(struct dla_processor *processor, + struct dla_processor_group *group); + int32_t (*enable)(struct dla_processor_group *group); + int32_t (*program)(struct dla_processor_group *group); + void (*set_producer)(int32_t group_id, int32_t rdma_id); + void (*dump_config)(struct dla_processor_group *group); + void (*rdma_check)(struct dla_processor_group *group); + void (*get_stat_data)(struct dla_processor *processor, + struct dla_processor_group *group); + void (*dump_stat)(struct dla_processor *processor); +}; + +struct dla_engine { + struct dla_task *task; + struct dla_config *config_data; + struct dla_network_desc *network; + struct dla_processor processors[DLA_OP_NUM]; + + uint16_t num_proc_hwl; + int32_t status; + uint32_t stat_enable; + + void *driver_context; +}; + +struct dla_engine *dla_get_engine(void); + +#endif diff --git a/drivers/nvdla/include/dla_err.h b/drivers/nvdla/include/dla_err.h new file mode 100644 index 000000000000..d9efcd08d8f7 --- /dev/null +++ b/drivers/nvdla/include/dla_err.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __FIRMWARE_DLA_ERR_H_ +#define __FIRMWARE_DLA_ERR_H_ + +#define ERR(code) -DLA_ERR_##code + +#define DLA_ERR_NONE 0 +#define DLA_ERR_INVALID_METHOD 1 +#define DLA_ERR_INVALID_TASK 2 +#define DLA_ERR_INVALID_INPUT 3 +#define DLA_ERR_INVALID_FALC_DMA 4 +#define DLA_ERR_INVALID_QUEUE 5 +#define DLA_ERR_INVALID_PREACTION 6 +#define DLA_ERR_INVALID_POSTACTION 7 +#define DLA_ERR_NO_MEM 8 +#define DLA_ERR_INVALID_DESC_VER 9 +#define DLA_ERR_INVALID_ENGINE_ID 10 +#define DLA_ERR_INVALID_REGION 11 +#define DLA_ERR_PROCESSOR_BUSY 12 +#define DLA_ERR_RETRY 13 +#define DLA_ERR_TASK_STATUS_MISMATCH 14 + +#endif diff --git a/drivers/nvdla/include/dla_interface.h b/drivers/nvdla/include/dla_interface.h new file mode 100644 index 000000000000..cbf4791bd909 --- /dev/null +++ b/drivers/nvdla/include/dla_interface.h @@ -0,0 +1,886 @@ +/* + * Copyright (c) 2017-2019, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __FIRMWARE_DLA_INTERFACE_H_ +#define __FIRMWARE_DLA_INTERFACE_H_ + +#include <nvdla_interface.h> + +/** + * @ingroup Processors + * @name DLA Processors + * Processor modules in DLA engine. Each processor has it's + * own operation a.k.a. HW layer. Network is formed using + * graph of these operations + * @{ + */ +#define DLA_OP_BDMA 0 +#define DLA_OP_CONV 1 +#define DLA_OP_SDP 2 +#define DLA_OP_PDP 3 +#define DLA_OP_CDP 4 +#define DLA_OP_RUBIK 5 +/** @} */ + +/** + * @ingroup Processors + * @name Maximum number of processors + * @brief DLA ash 6 processors + * @{ + */ +#define DLA_OP_NUM 6 +/** @} */ + +/** + * @ingroup Processors + * @name Number of groups + * @brief Each processor has 2 groups of registers + * @{ + */ +#define DLA_NUM_GROUPS 2 +/** @} */ + +/** + * Network descriptor + * + * Contains all information to execute a network + * + * @op_head: Index of first operation of each type in operations list + * @num_rois: Number of ROIs + * @num_operations: Number of operations in one list + * @num_luts: Number of LUTs + */ +struct dla_network_desc { + int16_t operation_desc_index; + int16_t surface_desc_index; + + int16_t dependency_graph_index; + int16_t lut_data_index; + + int16_t roi_array_index; + int16_t surface_index; + + int16_t stat_list_index; + int16_t reserved1; + + int16_t op_head[DLA_OP_NUM]; + + uint16_t num_rois; + uint16_t num_operations; + + uint16_t num_luts; + uint16_t num_addresses; + + int16_t input_layer; + uint8_t dynamic_roi; + uint8_t reserved0; +} __packed __aligned(4); + +/** + * @name Memory types + * @brief DLA engnine can read/write to/from 3 memory types + * @{ + */ +#define DLA_MEM_MC 0 /* External DRAM */ +#define DLA_MEM_CV 1 /* CV-SRAM */ +#define DLA_MEM_HW 2 /* DLA sub-module */ +/** @} */ + +/** + * @ingroup Events + * @name Operation events + * @brief Different events triggered by an operations + * @{ + */ +#define DLA_EVENT_OP_COMPLETED 1 +#define DLA_EVENT_OP_PROGRAMMED 2 +#define DLA_EVENT_OP_ENABLED 3 +#define DLA_EVENT_CDMA_WT_DONE 4 +#define DLA_EVENT_CDMA_DT_DONE 5 +/** @} */ + +struct dla_consumer { + int16_t index; /* the index of dla_common_op_desc in dep_graph_addr */ + uint8_t event; + uint8_t res; +} __packed __aligned(4); + +struct dla_common_op_desc { + int16_t index; /* set by ucode */ + int8_t roi_index; + uint8_t op_type; + + uint8_t dependency_count; + uint8_t reserved0[3]; + + struct dla_consumer consumers[DLA_OP_NUM]; + struct dla_consumer fused_parent; +} __packed __aligned(4); + +struct dla_roi_array_desc { + uint32_t array_length; + + uint32_t array_reserved; +} __packed __aligned(4); + +struct dla_roi_desc { + uint32_t left; + + uint32_t top; + + uint32_t right; + + uint32_t bottom; +} __packed __aligned(4); + +/** + * @ingroup BDMA + * @name Maximum BDMA transfers + * @brief BDMA supports multiple transfers in operation. This indicates + * maximum number of transfers possible in one operation. + * @{ + */ +#define NUM_MAX_BDMA_OPS 20 +/** @} */ + +struct dla_bdma_transfer_desc { + int16_t source_address; + int16_t destination_address; + + uint32_t line_size; + + uint32_t line_repeat; + + uint32_t source_line; + + uint32_t destination_line; + + uint32_t surface_repeat; + + uint32_t source_surface; + + uint32_t destination_surface; +} __packed __aligned(4); + +struct dla_bdma_surface_desc { + uint8_t source_type; + uint8_t destination_type; + uint16_t num_transfers; + + struct dla_bdma_transfer_desc transfers[NUM_MAX_BDMA_OPS]; +} __packed __aligned(4); + +struct dla_bdma_op_desc { + uint16_t num_transfers; + uint16_t reserved0; +} __packed __aligned(4); + +struct dla_bdma_stat_desc { + uint32_t read_stall; + uint32_t write_stall; + uint32_t runtime; +} __packed __aligned(4); + +/** + * @ingroup Convolution + * @name Convolution mode + * @brief Convolution modes support by DLA + * @{ + */ +#define CONV_MODE_DIRECT 0 +#define CONV_MODE_WINOGRAD 1 +/** @} */ + +/** + * @ingroup Processors + * @name Precision BPE mapping + * @brief Precision formats and Bit Per Elements mapping + * @{ + */ +#define BPE_PRECISION_INT8 1 +#define BPE_PRECISION_INT16 2 +#define BPE_PRECISION_FP16 2 +/** @} */ + + +/** + * @ingroup Processors + * @name Precision types + * @brief Precision formats supported by DLA engine + * @{ + */ +#define PRECISION_INT8 0 +#define PRECISION_INT16 1 +#define PRECISION_FP16 2 +/** @} */ + +/** + * @ingroup Processors + * @name Data formats + * @brief Data formats supported by DLA engine + * @{ + */ +#define FORMAT_T_R8 0 +#define FORMAT_T_R10 1 +#define FORMAT_T_R12 2 +#define FORMAT_T_R16 3 +#define FORMAT_T_R16_I 4 +#define FORMAT_T_R16_F 5 +#define FORMAT_T_A16B16G16R16 6 +#define FORMAT_T_X16B16G16R16 7 +#define FORMAT_T_A16B16G16R16_F 8 +#define FORMAT_T_A16Y16U16V16 9 +#define FORMAT_T_V16U16Y16A16 10 +#define FORMAT_T_A16Y16U16V16_F 11 +#define FORMAT_T_A8B8G8R8 12 +#define FORMAT_T_A8R8G8B8 13 +#define FORMAT_T_B8G8R8A8 14 +#define FORMAT_T_R8G8B8A8 15 +#define FORMAT_T_X8B8G8R8 16 +#define FORMAT_T_X8R8G8B8 17 +#define FORMAT_T_B8G8R8X8 18 +#define FORMAT_T_R8G8B8X8 19 +#define FORMAT_T_A2B10G10R10 20 +#define FORMAT_T_A2R10G10B10 21 +#define FORMAT_T_B10G10R10A2 22 +#define FORMAT_T_R10G10B10A2 23 +#define FORMAT_T_A2Y10U10V10 24 +#define FORMAT_T_V10U10Y10A2 25 +#define FORMAT_T_A8Y8U8V8 26 +#define FORMAT_T_V8U8Y8A8 27 +#define FORMAT_T_Y8___U8V8_N444 28 +#define FORMAT_T_Y8___V8U8_N444 29 +#define FORMAT_T_Y10___U10V10_N444 30 +#define FORMAT_T_Y10___V10U10_N444 31 +#define FORMAT_T_Y12___U12V12_N444 32 +#define FORMAT_T_Y12___V12U12_N444 33 +#define FORMAT_T_Y16___U16V16_N444 34 +#define FORMAT_T_Y16___V16U16_N444 35 +#define FORMAT_FEATURE 36 +/** @} */ + +/** + * @ingroup Convolution + * @name Pixel mapping + * @brief Pixel mapping formats supported for image input in Convolution + * @{ + */ +#define MAP_PITCH_LINEAR 0 +/** @} */ + +/** + * @ingroup Convolution + * @name Weight formats + * @brief Weight data formats supported in Convolution + * @{ + */ +#define WEIGHT_FORMAT_UNCOMPRESSED 0 +#define WEIGHT_FORMAT_COMPRESSED 1 +/** @} */ + +/** + * @ingroup Convolution + * @name Mean data format + * @brief Mean data formats supported in Convolution + * @{ + */ +#define MEAN_FORMAT_DISABLE 0 +#define MEAN_FORMAT_ENABLE 1 +/** @} */ + +struct dla_cvt_param { + int16_t scale; + uint8_t truncate; + uint8_t enable; + + int32_t offset; +} __packed __aligned(4); + +struct dla_data_cube { + uint16_t type; /* dla_mem_type */ + int16_t address; /* offset to the actual IOVA in task.address_list */ + + uint32_t offset; /* offset within address */ + uint32_t size; + + /* cube dimensions */ + uint16_t width; + uint16_t height; + + uint16_t channel; + uint16_t reserved0; + + /* stride information */ + uint32_t line_stride; + uint32_t surf_stride; + + /* For Rubik only */ + uint32_t plane_stride; +} __packed __aligned(4); + +#define PIXEL_OVERRIDE_UINT 0 +#define PIXEL_OVERRIDE_INT 1 + +struct dla_conv_surface_desc { + /* Data cube */ + struct dla_data_cube weight_data; + struct dla_data_cube wmb_data; + struct dla_data_cube wgs_data; + struct dla_data_cube src_data; + struct dla_data_cube dst_data; + + /** + * u_addr = input_data.source_addr + offset_u + * this field should be set when YUV is not interleave format + * + */ + int64_t offset_u; + + /* line stride for 2nd plane, must be 32bytes aligned */ + uint32_t in_line_uv_stride; +} __packed __aligned(4); + +struct dla_conv_op_desc { + /* Performance parameters */ + + /* dla_conv_mode */ + uint8_t conv_mode; + uint8_t data_reuse; + uint8_t weight_reuse; + uint8_t skip_data_rls; + + uint8_t skip_weight_rls; + uint8_t reserved0; + uint16_t entry_per_slice; + + /* dla_data_format */ + uint8_t data_format; + /* dla_pixel_mapping */ + uint8_t pixel_mapping; + /* number of free slices before fetch */ + uint16_t fetch_grain; + + uint8_t reserved_b[8]; + + /* batch_num */ + uint8_t batch; + /* dla_weight_format */ + uint8_t weight_format; + uint8_t data_bank; + uint8_t weight_bank; + + /* the offset in bytes of each data cube in a batch */ + uint32_t batch_stride; + + uint8_t post_extension; + uint8_t pixel_override; + /* number of slices need to be released */ + uint16_t release; + + /* The input cube dimension for CSC */ + uint16_t input_width_csc; + uint16_t input_height_csc; + + uint16_t input_channel_csc; + uint16_t kernel_width_csc; + + uint16_t kernel_height_csc; + uint16_t kernel_channel_csc; + + /* The input cube dimension for CMAC */ + uint16_t input_width_cmac; + uint16_t input_height_cmac; + + /* actual size in bytes */ + uint32_t bytes_per_kernel; + + /* Algorithm parameters */ + + int16_t mean_ry; /* mean value for red in RGB or Y in YUV */ + int16_t mean_gu; /* mean value for green in RGB or U in YUV */ + + int16_t mean_bv; /* mean value for blue in RGB or V in YUV */ + int16_t mean_ax; + + uint8_t mean_format; /* dla_mean_format */ + uint8_t conv_stride_x; + uint8_t conv_stride_y; + uint8_t pad_x_left; + + uint8_t pad_x_right; + uint8_t pad_y_top; + uint8_t pad_y_bottom; + uint8_t dilation_x; + + uint8_t dilation_y; + uint8_t reserved2[2]; + + /* Precision parameters */ + uint8_t pra_truncate; + + uint8_t in_precision; + /* The output precision from CONV, it's the MAC processing precison */ + uint8_t out_precision; + int16_t pad_val; + + /* input converter parameters */ + struct dla_cvt_param in_cvt; + /* output converter parameters, support truncate only */ + struct dla_cvt_param out_cvt; + +} __packed __aligned(4); + +struct dla_conv_stat_desc { + uint32_t data_read_stall; + uint32_t weight_read_stall; + uint32_t data_read_latency; + uint32_t weight_read_latency; + uint32_t saturation_count; + uint32_t nan_data_num; + uint32_t nan_weight_num; + uint32_t inf_data_num; + uint32_t inf_weight_num; + uint32_t runtime; +} __packed __aligned(4); + +/** + * @ingroup SDP + * @name Activation functions + * @brief Activation functions supported in SDP + * @{ + */ +#define ACTIVATION_NONE 0 +#define ACTIVATION_RELU 1 +#define ACTIVATION_LUT 2 +#define ACTIVATION_PRELU 3 +/** @} */ + +/** + * @ingroup LUT + * @name LUT size + * @brief LUT sizes for linear and exponentila LUT + * @{ + */ +#define LUT_LINEAR_EXP_TABLE_ENTRY_LOG2 6 +#define LUT_LINEAR_ONLY_TABLE_ENTRY_LOG2 8 +/** @} */ + +/** + * @ingroup LUT + * @name LUT types + * @brief DLA supports two types of LUT, linear and exonential + * @{ + */ +#define LUT_LINEAR_EXP_TABLE 0 +#define LUT_LINEAR_ONLY_TABLE 1 +/** @} */ + +/** + * @ingroup LUT + * @name LUT methods + * @brief DLA supports two types of LUT, linear and exonential + * @{ + */ +#define LUT_METHOD_EXPONENTIAL 0 +#define LUT_METHOD_LINEAR 1 +/** @} */ + +/** + * @ingroup LUT + * @name LUT + * @brief DLA supports two types of LUT, linear and exonential + * @{ + */ +#define LUT_PRI_LINEAR_EXP 0 +#define LUT_PRI_LINEAR_ONLY 1 +/** @} */ + +union dla_lut_offset { + /** + * Number should be substracted on log domain before look up + * exponetial table it has the same definition as hardware + * thus input scaling should also take into account when + * set this field. + */ + int8_t exp_offset; + /** + * Number of bits should be right shift before looking + * up linear table + */ + int8_t frac_bits; + uint16_t reserved0; +}; + +/** + * This struct is used to represent floating point values by INT + * suppose we have a float point number fp_x, it will be represented + * as: + * + * fp_x = scale_int_x>>(shifter_x) + * + * This is very useful for INT pipeline; + */ +struct dla_float_data { + int16_t scale; + int8_t shifter; + uint8_t reserved0; +} __packed __aligned(4); + +/** + * For INT pipeline, we use the struct above to represent a floating number; + * For FP16 pipeline, we should store the FP16 encoded value into a uint16_t + * container + */ +union dla_slope { + struct dla_float_data data_i; + + uint16_t data_f; +}; + +struct dla_lut_param { + /** + * value of expression ((1<<LUT_LINEAR_EXP_TABLE_ENTRY_LOG2)+1) is 65, + * ((1<<LUT_LINEAR_ONLY_TABLE_ENTRY_LOG2)+1) is 257, and int16_t is of + * 2Byte. And below two statement's combined memory size is 644 Byte. + * + * NOTE: below two declaration combined size should always be multiple + * of 4. + */ + int16_t linear_exp_table[(1<<LUT_LINEAR_EXP_TABLE_ENTRY_LOG2)+1]; + int16_t linear_only_table[(1<<LUT_LINEAR_ONLY_TABLE_ENTRY_LOG2)+1]; + + union dla_lut_offset linear_exp_offset; + union dla_lut_offset linear_only_offset; + + /** + * The start and end point of raw table, + * valid when raw_method=LINEAR only + */ + uint64_t linear_exp_start; + uint64_t linear_exp_end; + uint64_t linear_only_start; + uint64_t linear_only_end; + + union dla_slope linear_exp_underflow_slope; + union dla_slope linear_exp_overflow_slope; + union dla_slope linear_only_underflow_slope; + union dla_slope linear_only_overflow_slope; + + /** + * dla_lut_priority, when both lut are hit(or one overflow, + * the other underflow), which one should be selected as output + */ + uint8_t hybrid_priority; + uint8_t underflow_priority; + uint8_t overflow_priority; + uint8_t method; /* dla_lut_method */ +} __packed __aligned(4); + +struct dla_sdp_surface_desc { + /* Data cube */ + /* source input cube, available when SDP working on offline mode */ + struct dla_data_cube src_data; + + /* X1 input cube */ + struct dla_data_cube x1_data; + + /* X2 input cube */ + struct dla_data_cube x2_data; + + /* Y input cube */ + struct dla_data_cube y_data; + + /* Output cube */ + struct dla_data_cube dst_data; +} __packed __aligned(4); + +#define SDP_OP_NONE 0 +#define SDP_OP_MUL 1 +#define SDP_OP_ADD 2 +#define SDP_OP_BOTH 3 + +#define SDP_ALU_OP_MAX 0 +#define SDP_ALU_OP_MIN 1 +#define SDP_ALU_OP_SUM 2 +#define SDP_ALU_OP_EQL 3 + +#define SDP_OP_PER_LAYER 0 +#define SDP_OP_PER_KERNEL 1 +#define SDP_OP_PER_POINT 2 + +struct dla_sdp_cvt { + struct dla_cvt_param alu_cvt; + struct dla_cvt_param mul_cvt; +} __packed __aligned(4); + +struct dla_sdp_op { + uint8_t enable; + uint8_t alu_type; /* dla_sdp_alu_op_type */ + uint8_t type; /* dla_sdp_op_type */ + uint8_t mode; /* dla_sdp_op_mode */ + + uint8_t act; /* dla_act_type */ + uint8_t shift_value; /* left shift */ + uint8_t truncate; + uint8_t precision; + + int32_t alu_operand; + int32_t mul_operand; + + struct dla_sdp_cvt cvt; +} __packed __aligned(4); + +struct dla_sdp_op_desc { + /* Precision parameters */ + /* dla_precision */ + uint8_t src_precision; + uint8_t dst_precision; + int16_t lut_index; + + struct dla_cvt_param out_cvt; + + /* Performance parameters */ + /* dla_conv_mode */ + uint8_t conv_mode; + uint8_t batch_num; + uint16_t reserved0; + + uint32_t batch_stride; /* will be used when batch_num > 1 */ + + /* Algorithm parameters */ + struct dla_sdp_op x1_op; + struct dla_sdp_op x2_op; + struct dla_sdp_op y_op; +} __packed __aligned(4); + +struct dla_sdp_stat_desc { + uint32_t nan_input_num; + uint32_t inf_input_num; + uint32_t nan_output_num; + uint32_t wdma_write_stall; + uint32_t lut_underflow; + uint32_t lut_overflow; + uint32_t lut_hybrid; + uint32_t lut_le_hit; + uint32_t lut_lo_hit; + uint32_t saturation_count; + uint32_t runtime; +} __packed __aligned(4); + +#define POOL_MODE_AVG 0 +#define POOL_MODE_MAX 1 +#define POOL_MODE_MIN 2 + +#define POOL_SIZE_1 0 +#define POOL_SIZE_2 1 +#define POOL_SIZE_3 2 +#define POOL_SIZE_4 3 +#define POOL_SIZE_5 4 +#define POOL_SIZE_6 5 +#define POOL_SIZE_7 6 +#define POOL_SIZE_8 7 + +#define PDP_PAD_VAL_NUM 7 + +struct dla_pdp_surface_desc { + /* Data cube */ + struct dla_data_cube src_data; + + struct dla_data_cube dst_data; +} __packed __aligned(4); + +struct dla_pdp_op_desc { + /* Performance parameters */ + uint16_t partial_in_width_first; + uint16_t partial_in_width_mid; + + uint16_t partial_in_width_last; + uint16_t partial_width_first; + + uint16_t partial_width_mid; + uint16_t partial_width_last; + + uint8_t split_num; + + /* Algorithm parameters */ + uint8_t pool_mode; /* dla_pool_mode */ + uint8_t pool_width; /* dla_pool_width */ + uint8_t pool_height; /* dla_pool_height */ + + uint8_t stride_x; + uint8_t stride_y; + + /** + * The left/right padding size, + * pad_right might be less than pad_left + */ + uint8_t pad_left; + uint8_t pad_right; + + /* The top/bottom padding size */ + uint8_t pad_top; + uint8_t pad_bottom; + + /* Precision parameters */ + uint8_t precision; /* dla_precision */ + uint8_t reserved0; + /** + * if input has non-zero "offset", this value should be set + * There'll be 7 different paddding values, the relationship between + * those versions are: + * padding_value[0] = -offset*scaling; + * padding_value[1] = 2*padding_value[0] + * padding_value[2] = 3*padding_value[0] + * ... + * The purpose is to avoid ucode implement FP16 + * multiplier(for FP16 mode) + */ + int32_t padding_value[PDP_PAD_VAL_NUM]; +} __packed __aligned(4); + +struct dla_pdp_stat_desc { + uint32_t inf_input_num; + uint32_t nan_input_num; + uint32_t nan_output_num; + uint32_t write_stall; + uint32_t runtime; +} __packed __aligned(4); + +struct dla_cdp_surface_desc { + /* Data cube */ + struct dla_data_cube src_data; + + struct dla_data_cube dst_data; +} __packed __aligned(4); + +struct dla_cdp_op_desc { + /* Precision parameters */ + + /* dla_precision */ + uint8_t in_precision; + uint8_t out_precision; + int16_t lut_index; + + struct dla_cvt_param in_cvt; + struct dla_cvt_param out_cvt; + + /* Performance parameters */ + + /* Algorithm parameters */ + uint8_t local_size; + uint8_t bypass_sqsum; + uint8_t bypass_out_mul; + uint8_t reserved0; +} __packed __aligned(4); + +struct dla_cdp_stat_desc { + uint32_t nan_input_num; + uint32_t inf_input_num; + uint32_t nan_output_num; + uint32_t write_stall; + uint32_t lut_uflow; + uint32_t lut_oflow; + uint32_t lut_hybrid; + uint32_t lut_le_hit; + uint32_t lut_lo_hit; + uint32_t saturation_count; + uint32_t runtime; +} __packed __aligned(4); + +struct dla_rubik_surface_desc { + /* Data cube */ + struct dla_data_cube src_data; + + struct dla_data_cube dst_data; +} __packed __aligned(4); + +/* rubik mode */ +#define RUBIK_MODE_CONTRACT 0 +#define RUBIK_MODE_SPLIT 1 +#define RUBIK_MODE_MERGE 2 + +struct dla_rubik_op_desc { + /* Precision parameters */ + uint8_t mode; + uint8_t precision; + uint8_t stride_x; + uint8_t stride_y; +} __packed __aligned(4); + +struct dla_rubik_stat_desc { + uint32_t read_stall; + uint32_t write_stall; + uint32_t runtime; +} __packed __aligned(4); + +union dla_surface_container { + struct dla_bdma_surface_desc bdma_surface; + struct dla_conv_surface_desc conv_surface; + struct dla_sdp_surface_desc sdp_surface; + struct dla_pdp_surface_desc pdp_surface; + struct dla_cdp_surface_desc cdp_surface; + struct dla_rubik_surface_desc rubik_surface; +}; + +union dla_operation_container { + struct dla_bdma_op_desc bdma_op; + struct dla_conv_op_desc conv_op; + struct dla_sdp_op_desc sdp_op; + struct dla_pdp_op_desc pdp_op; + struct dla_cdp_op_desc cdp_op; + struct dla_rubik_op_desc rubik_op; +}; + +union dla_stat_container { + struct dla_bdma_stat_desc bdma_stat; + struct dla_conv_stat_desc conv_stat; + struct dla_sdp_stat_desc sdp_stat; + struct dla_pdp_stat_desc pdp_stat; + struct dla_cdp_stat_desc cdp_stat; + struct dla_rubik_stat_desc rubik_stat; +}; + +/** + * status notifier structure + * + * @address: 64-bit timestamp representing the time at which + * the notifier was written + * @status_engine: status work captured from HW engine + * @subframe: NA + * @status_task: status word as configured from an action list + */ +struct dla_task_status { + uint64_t timestamp; + + uint32_t status_engine; + + uint16_t subframe; + uint16_t status_task; +} __packed __aligned(4); + +#endif diff --git a/drivers/nvdla/include/dla_sched.h b/drivers/nvdla/include/dla_sched.h new file mode 100644 index 000000000000..7ed35487da16 --- /dev/null +++ b/drivers/nvdla/include/dla_sched.h @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2017-2018, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DLA_SCHED_H_ +#define __DLA_SCHED_H_ + +struct dla_task { + /* platform specific data to communicate with portability layer */ + void *task_data; + /* task state */ + uint32_t state; + /* Task base address */ + uint64_t base; + /* start address of a list of dla_operation_container */ + uint64_t operation_desc_addr; + /* start address of a list of dla_surface_container */ + uint64_t surface_desc_addr; + /* start address of a list of dla_common_op_desc */ + uint64_t dependency_graph_addr; + /* start address of a list of dla_lut_param */ + uint64_t lut_data_addr; + /* + * start address of a list of dla_roi_desc, + * the first one is dla_roi_array_desc + * valid when network.dynamic_roi is true + */ + uint64_t roi_array_addr; + /* start address of a list of dla_surface_container */ + uint64_t surface_addr; + /* start address of a list of dla_stat_container */ + uint64_t stat_data_addr; +} __packed __aligned(256); + +/** + * @brief Configuration parameters supported by the engine + * + * atom_size Memory smallest access size + * bdma_enable Defines whether bdma is supported + * rubik_enable Defines whether rubik is supported + * weight_compress_support Defines whether weight data compression is supported + */ +struct dla_config { + uint32_t atom_size; + bool bdma_enable; + bool rubik_enable; + bool weight_compress_support; +}; + +#endif diff --git a/drivers/nvdla/include/nvdla_interface.h b/drivers/nvdla/include/nvdla_interface.h new file mode 100644 index 000000000000..7ad40b4c3db0 --- /dev/null +++ b/drivers/nvdla/include/nvdla_interface.h @@ -0,0 +1,327 @@ +/* + * Copyright (c) 2017-2018, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __NVDLA_INTERFACE_H_ +#define __NVDLA_INTERFACE_H_ + +#include <linux/types.h> + +/** + * @brief Register driver to firmware + * + * Implementation in firmware, called by portability layer + * + * This function must be called once during boot to initialize DLA + * engine scheduler and register driver with firmware before submitting + * any task. Pass pointer to driver context in @param driver_context + * which is passed as param when firmware calls any function + * of portability layer. It also updates pointer to engine context + * which must be passed in any function call to firmware after this point. + * + * @param engine_context Pointer to engine specific data + * @param driver_context Pointer to driver specific data + * + * @return 0 on success and negative on error + */ +int32_t dla_register_driver(void **engine_context, void *driver_context); + +/** + * @brief Interrupt handler + * + * Implementation in firmware, called by portability layer + * + * This function is called when DLA interrupt is received. Portability layer + * should register it's own handler using the mechanism supported by that platform + * and call this function from the handler. Call to this function must be + * protected by lock to prevent handling interrupt when firmware is programming + * layers in process context. + * + * @param engine_context Engine specific data received in dla_register_driver + * + * @return 0 on success and negative on error + */ +int32_t dla_isr_handler(void *engine_context); + +/** + * @brief Process events recorded in interrupt handler + * + * Implementation in firmware, called by portability layer + * + * Interrupt handler just records events and does not process those events. + * Portability layer must call this function in thread/process context after + * interrupt handler is done. + * + * @param engine_context Engine specific data received in dla_register_driver + * @param task_complete Pointer to parameter to indicate task complete, + firmare writes 1 to it if all layers are processed. + * + * @return 0 on success and negative on error + * + */ +int32_t dla_process_events(void *engine_context, uint32_t *task_complete); + +/** + * @brief Clear task from firmware + * + * Implementation in firmware, called by portability layer + * + * This function resets engine scheduler state including op descriptor cache, + * error values, sub-engine status, events etc and clears previous task state + * from firmware. This function can be called by portability layer after + * task completion. It is not mandatory to call it but calling it will + * ensure clean state before next task execution. + * + * @param engine_context Engine specific data received in dla_register_driver + * + * @return 0 on success and negative on error + * + */ +void dla_clear_task(void *engine_context); + +/** + * @brief Execute task + * + * Implementation in firmware, called by portability layer + * + * This function initializes sub-engines and starts task execution. Further + * programming and layer scheduling is triggered by events received from + * hardware. + * + * @param engine_context Engine specific data received in dla_register_driver + * @param task_data Task specific data to be passed when reading task info + * @param config_data Configuration data to be passed + * + * @return 0 on success and negative on error + * + */ +int32_t dla_execute_task(void *engine_context, void *task_data, void *config_data); + +/** + * @brief Register read + * + * Implementation in portability layer, called by firmware + * + * Read DLA HW register. Portability layer is responsible to use correct + * base address and for any IO mapping if required. + * + * @param engine_context Driver specific data received in dla_register_driver + * @param addr Register offset + * + * @return Register value + * + */ +uint32_t dla_reg_read(void *driver_context, uint32_t addr); + +/** + * @brief Register write + * + * Implementation in portability layer, called by firmware + * + * Write DLA HW registr. Portability layer is responsible to use correct + * base address and for any IO mapping if required. + * + * @param driver_context Driver specific data received in dla_register_driver + * @param addr Register offset + * @param reg Value to write + * + */ +void dla_reg_write(void *driver_context, uint32_t addr, uint32_t reg); + +/** + * @brief Read data from DMA mapped memory in local buffer + * + * Implementation in portability layer, called by firmware + * + * This function reads data from buffers passed by UMD in local memory. + * Addresses for buffers passed by are shared in address list and network + * descriptor contains index in address list for those buffers. Firmware + * reads this data from buffer shared by UMD into local buffer to consume + * the information. + * + * @param driver_context Driver specific data received in dla_register_driver + * @param task_data Task specific data received in dla_execute_task + * @param src Index in address list + * @param dst Pointer to local memory + * @param size Size of data to copy + * @param offset Offset from start of UMD buffer + * + * @return 0 on success and negative on error + * + */ +int32_t dla_data_read(void *driver_context, void *task_data, + uint64_t src, void *dst, + uint32_t size, uint64_t offset); + +/** + * @brief Write data to DMA mapped memory from local buffer + * + * Implementation in portability layer, called by firmware + * + * This function writes data from local buffer to buffer passed by UMD. + * Addresses for buffers passed by are shared in address list and network + * descriptor contains index in address list for those buffers. Firmware + * writes this data to buffer shared by UMD from local buffer to update + * the information. + * + * @param driver_context Driver specific data received in dla_register_driver + * @param task_data Task specific data received in dla_execute_task + * @param src Pointer to local memory + * @param dst Index in address list + * @param size Size of data to copy + * @param offset Offset from start of UMD buffer + * + * @return 0 on success and negative on error + * + */ +int32_t dla_data_write(void *driver_context, void *task_data, + void *src, uint64_t dst, + uint32_t size, uint64_t offset); + +/* Destination for DMA buffer */ +#define DESTINATION_PROCESSOR 0 +#define DESTINATION_DMA 1 + +/** + * @brief Read DMA address + * + * Implementation in portability layer, called by firmware + * + * Some buffers shared by UMD are accessed by processor responsible for + * programming DLA HW. It would be companion micro-controller in case of + * headed config while main CPU in case of headless config. Also, some + * buffers are accessed by DLA DMA engines inside sub-engines. This function + * should return proper address accessible by destination user depending + * on config. + * + * @param driver_context Driver specific data received in dla_register_driver + * @param task_data Task specific data received in dla_execute_task + * @param index Index in address list + * @param dst_ptr Pointer to update address + * @param destination Destination user for DMA address + * + * @return 0 on success and negative on error + * + */ +int32_t dla_get_dma_address(void *driver_context, void *task_data, + int16_t index, void *dst_ptr, + uint32_t destination); + +/** + * @brief Read time value in micro-seconds + * + * Implementation in portability layer, called by firmware + * + * Read system time in micro-seconds + * + * @return Time value in micro-seconds + * + */ +int64_t dla_get_time_us(void); + +/** + * @brief Print debug message + * + * Implementation in portability layer, called by firmware + * + * Print debug message to console + * + * @param str Format string and variable arguments + * + */ +void dla_debug(const char *str, ...); + +/** + * @brief Print information message + * + * Implementation in portability layer, called by firmware + * + * Print information message to console + * + * @param str Format string and variable arguments + * + */ +void dla_info(const char *str, ...); + +/** + * @brief Print warning message + * + * Implementation in portability layer, called by firmware + * + * Print warning message to console + * + * @param str Format string and variable arguments + * + */ +void dla_warn(const char *str, ...); + +/** + * @brief Print error message + * + * Implementation in portability layer, called by firmware + * + * Print error message to console + * + * @param str Format string and variable arguments + * + */ +void dla_error(const char *str, ...); + +/** + * @brief Fill memory region + * + * Implementation in portability layer, called by firmware + * + * Fills the first len bytes of the memory area pointed to by src + * with the constant byte ch. + * + * @param src Memory area address + * @param ch Byte to fill + * @param len Length of memory area to fill + * + * @return Memory area address + * + */ +void *dla_memset(void *src, int ch, uint64_t len); + +/** + * @brief Copy memory + * + * Implementation in portability layer, called by firmware + * + * Copies len bytes from memory area src to memory area dest. + * + * @param dest Destination memory area address + * @param src Source memory area address + * @param len Length of memory area to copy + * + * @return Destination memory area address + * + */ +void *dla_memcpy(void *dest, const void *src, uint64_t len); + +#endif diff --git a/drivers/nvdla/include/nvdla_ioctl.h b/drivers/nvdla/include/nvdla_ioctl.h new file mode 100644 index 000000000000..3c8ec3a6cd51 --- /dev/null +++ b/drivers/nvdla/include/nvdla_ioctl.h @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2017-2018, NVIDIA CORPORATION. All rights reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation; or, when distributed + * separately from the Linux kernel or incorporated into other + * software packages, subject to the following license: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __LINUX_NVDLA_IOCTL_H +#define __LINUX_NVDLA_IOCTL_H + +#include <linux/ioctl.h> +#include <linux/types.h> + +#if !defined(__KERNEL__) +#define __user +#endif + +/** + * struct nvdla_mem_handle structure for memory handles + * + * @handle handle to DMA buffer allocated in userspace + * @reserved Reserved for padding + * @offset offset in bytes from start address of buffer + * + */ +struct nvdla_mem_handle { + __u32 handle; + __u32 reserved; + __u64 offset; +}; + +/** + * struct nvdla_ioctl_submit_task structure for single task information + * + * @num_addresses total number of entries in address_list + * @reserved Reserved for padding + * @address_list pointer to array of struct nvdla_mem_handle + * + */ +struct nvdla_ioctl_submit_task { +#define NVDLA_MAX_BUFFERS_PER_TASK (6144) + __u32 num_addresses; +#define NVDLA_NO_TIMEOUT (0xffffffff) + __u32 timeout; + __u64 address_list; +}; + +/** + * struct nvdla_submit_args structure for task submit + * + * @tasks pointer to array of struct nvdla_ioctl_submit_task + * @num_tasks number of entries in tasks + * @flags flags for task submit, no flags defined yet + * @version version of task structure + * + */ +struct nvdla_submit_args { + __u64 tasks; + __u16 num_tasks; +#define NVDLA_MAX_TASKS_PER_SUBMIT 24 +#define NVDLA_SUBMIT_FLAGS_ATOMIC (1 << 0) + __u16 flags; + __u32 version; +}; + +/** + * struct nvdla_gem_create_args for allocating DMA buffer through GEM + * + * @handle handle updated by kernel after allocation + * @flags implementation specific flags + * @size size of buffer to allocate + */ +struct nvdla_gem_create_args { + __u32 handle; + __u32 flags; + __u64 size; +}; + +/** + * struct nvdla_gem_map_offset_args for mapping DMA buffer + * + * @handle handle of the buffer + * @reserved reserved for padding + * @offset offset updated by kernel after mapping + */ +struct nvdla_gem_map_offset_args { + __u32 handle; + __u32 reserved; + __u64 offset; +}; + +/** + * struct nvdla_gem_destroy_args for destroying DMA buffer + * + * @handle handle of the buffer + */ +struct nvdla_gem_destroy_args { + __u32 handle; +}; + +#define DRM_NVDLA_SUBMIT 0x00 +#define DRM_NVDLA_GEM_CREATE 0x01 +#define DRM_NVDLA_GEM_MMAP 0x02 +#define DRM_NVDLA_GEM_DESTROY 0x03 + +#define DRM_IOCTL_NVDLA_SUBMIT DRM_IOWR(DRM_COMMAND_BASE + DRM_NVDLA_SUBMIT, struct nvdla_submit_args) +#define DRM_IOCTL_NVDLA_GEM_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_NVDLA_GEM_CREATE, struct nvdla_gem_create_args) +#define DRM_IOCTL_NVDLA_GEM_MMAP DRM_IOWR(DRM_COMMAND_BASE + DRM_NVDLA_GEM_MMAP, struct nvdla_gem_map_offset_args) +#define DRM_IOCTL_NVDLA_GEM_DESTROY DRM_IOWR(DRM_COMMAND_BASE + DRM_NVDLA_GEM_DESTROY, struct nvdla_gem_destroy_args) + +#endif diff --git a/drivers/nvdla/include/nvdla_linux.h b/drivers/nvdla/include/nvdla_linux.h new file mode 100644 index 000000000000..2fc543dfa1c4 --- /dev/null +++ b/drivers/nvdla/include/nvdla_linux.h @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2017-2018, NVIDIA CORPORATION. All rights reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation; or, when distributed + * separately from the Linux kernel or incorporated into other + * software packages, subject to the following license: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __LINUX_NVDLA_LINUX_H_ +#define __LINUX_NVDLA_LINUX_H_ + +#include <linux/completion.h> +#include <linux/device.h> +#include <linux/kref.h> +#include <linux/platform_device.h> +#include <linux/spinlock.h> + +/** + * @brief Task information submitted from user space + * + * ref Reference count for task + * num_addresses Number of addresses in address list + * nvdla_dev Pointer to NVDLA device + * address_list Address list + * file DRM file instance + */ +struct nvdla_task { + struct kref ref; + uint32_t num_addresses; + struct nvdla_device *nvdla_dev; + struct nvdla_mem_handle *address_list; + struct drm_file *file; +}; + +/** + * @brief Configuration parameters supported by the engine + * + * atom_size Memory smallest access size + * bdma_enable Defines whether bdma is supported + * rubik_enable Defines whether rubik is supported + * weight_compress_support Defines whether weight data compression is supported + */ +struct nvdla_config +{ + uint32_t atom_size; + bool bdma_enable; + bool rubik_enable; + bool weight_compress_support; +}; + +/** + * @brief NVDLA device + * + * irq Interrupt number associated with this device + * ref Reference count for device + * base IO mapped base address for device + * nvdla_lock Spinlock used for synchronization + * drm DRM device instance + * task Pointer to task in execution + * config_data Pointer to the configuration data + * pdev Pointer to NVDLA platform device + * event_notifier Completion object used to wait for events from HW + * engine_context Private data passed from engine in dla_engine_init + */ +struct nvdla_device { + int32_t irq; + struct kref ref; + void __iomem *base; + spinlock_t nvdla_lock; + struct drm_device *drm; + struct nvdla_task *task; + struct nvdla_config *config_data; + struct platform_device *pdev; + struct completion event_notifier; + + void *engine_context; +}; + +/** + * @brief Submit task + * + * This function submits task to NVDLA engine. + * + * @param nvdla_dev Pointer to NVDLA device + * @param task Pointer to task + * @return 0 on success and negative on error + * + */ +int32_t nvdla_task_submit(struct nvdla_device *nvdla_dev, struct nvdla_task *task); + +/** + * @brief Get DMA address + * + * This function gets DMA address for given fd + * + * @param dev DRM device instance + * @param file DRM file instance + * @param fd File desriptor for DMA buffer + * @param addr Pointer to update DMA address + * @return 0 on success and negative on error + * + */ +int32_t nvdla_gem_dma_addr(struct drm_device *dev, struct drm_file *file, + uint32_t fd, dma_addr_t *addr); + +/** + * @brief DRM probe + * + * Probe function for DRM device + * + * @param nvdla_dev NVDLA device pointer + * @return 0 on success and negative on error + * + */ +int32_t nvdla_drm_probe(struct nvdla_device *nvdla_dev); + +/** + * @brief DRM remove + * + * Remove function for DRM device + * + * @param nvdla_dev NVDLA device pointer + * + */ +void nvdla_drm_remove(struct nvdla_device *nvdla_dev); + +#endif diff --git a/drivers/nvdla/include/opendla.h b/drivers/nvdla/include/opendla.h new file mode 100644 index 000000000000..41d7e30fb10d --- /dev/null +++ b/drivers/nvdla/include/opendla.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __OPENDLA_H_ +#define __OPENDLA_H_ + +#define DLA_2_CONFIG +#define CONFIG_NVDLA_NEED_FLUSH + +#ifdef DLA_2_CONFIG +#include <opendla_small.h> +#else +#include <opendla_initial.h> +#endif + +#ifdef CONFIG_NVDLA_NEED_FLUSH +#include <soc/starfive/vic7100.h> +#define nvdla_flush_dcache starfive_flush_dcache +#else +#define nvdla_flush_dcache +#endif + +#endif diff --git a/drivers/nvdla/include/opendla_initial.h b/drivers/nvdla/include/opendla_initial.h new file mode 100644 index 000000000000..71335438f5d4 --- /dev/null +++ b/drivers/nvdla/include/opendla_initial.h @@ -0,0 +1,16743 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __ARNVDLA_H_ +#define __ARNVDLA_H_ + +// Register GLB_S_NVDLA_HW_VERSION_0 +#define GLB_S_NVDLA_HW_VERSION_0 (_MK_ADDR_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_SECURE (0x0) +#define GLB_S_NVDLA_HW_VERSION_0_DUAL (0x0) +#define GLB_S_NVDLA_HW_VERSION_0_SCR (0) +#define GLB_S_NVDLA_HW_VERSION_0_WORD_COUNT (0x1) +#define GLB_S_NVDLA_HW_VERSION_0_RESET_VAL (_MK_MASK_CONST(0x303031)) +#define GLB_S_NVDLA_HW_VERSION_0_RESET_MASK (_MK_MASK_CONST(0xffffff)) +#define GLB_S_NVDLA_HW_VERSION_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_READ_MASK (_MK_MASK_CONST(0xffffff)) +#define GLB_S_NVDLA_HW_VERSION_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_SHIFT (_MK_SHIFT_CONST(0)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_FIELD \ + (_MK_FIELD_CONST(0xff, GLB_S_NVDLA_HW_VERSION_0_MAJOR_SHIFT)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_RANGE (7:0) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_WOFFSET (0x0) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_DEFAULT (_MK_MASK_CONST(0x31)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_DEFAULT_MASK (_MK_MASK_CONST(0xff)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_SHIFT (_MK_SHIFT_CONST(8)) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_FIELD \ + (_MK_FIELD_CONST(0xffff, GLB_S_NVDLA_HW_VERSION_0_MINOR_SHIFT)) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_RANGE (23:8) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_WOFFSET (0x0) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_DEFAULT (_MK_MASK_CONST(0x3030)) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register GLB_S_INTR_MASK_0 +#define GLB_S_INTR_MASK_0 (_MK_ADDR_CONST(0x4)) +#define GLB_S_INTR_MASK_0_SECURE (0x0) +#define GLB_S_INTR_MASK_0_DUAL (0x0) +#define GLB_S_INTR_MASK_0_SCR (0) +#define GLB_S_INTR_MASK_0_WORD_COUNT (0x1) +#define GLB_S_INTR_MASK_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RESET_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_MASK_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_READ_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_MASK_0_WRITE_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_SDP_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_RANGE (0:0) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(1)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_SDP_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_RANGE (1:1) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(2)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDP_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_RANGE (2:2) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(3)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDP_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_RANGE (3:3) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(4)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_PDP_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_RANGE (4:4) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(5)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_PDP_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_RANGE (5:5) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(6)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_RANGE (6:6) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(7)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_RANGE (7:7) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(8)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_RANGE (8:8) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(9)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_RANGE (9:9) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(16)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_RANGE (16:16) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(17)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_RANGE (17:17) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(18)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_RANGE (18:18) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(19)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_RANGE (19:19) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_SHIFT (_MK_SHIFT_CONST(20)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CACC_DONE_MASK0_SHIFT)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_RANGE (20:20) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_SHIFT (_MK_SHIFT_CONST(21)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CACC_DONE_MASK1_SHIFT)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_RANGE (21:21) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_WOFFSET (0x0) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register GLB_S_INTR_SET_0 +#define GLB_S_INTR_SET_0 (_MK_ADDR_CONST(0x8)) +#define GLB_S_INTR_SET_0_SECURE (0x0) +#define GLB_S_INTR_SET_0_DUAL (0x0) +#define GLB_S_INTR_SET_0_SCR (0) +#define GLB_S_INTR_SET_0_WORD_COUNT (0x1) +#define GLB_S_INTR_SET_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RESET_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_SET_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_READ_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_WRITE_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_SHIFT (_MK_SHIFT_CONST(0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_SDP_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_RANGE (0:0) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_SHIFT (_MK_SHIFT_CONST(1)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_SDP_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_RANGE (1:1) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_SHIFT (_MK_SHIFT_CONST(2)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDP_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_RANGE (2:2) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_SHIFT (_MK_SHIFT_CONST(3)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDP_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_RANGE (3:3) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_SHIFT (_MK_SHIFT_CONST(4)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_PDP_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_RANGE (4:4) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_SHIFT (_MK_SHIFT_CONST(5)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_PDP_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_RANGE (5:5) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_SHIFT (_MK_SHIFT_CONST(6)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_BDMA_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_RANGE (6:6) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_SHIFT (_MK_SHIFT_CONST(7)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_BDMA_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_RANGE (7:7) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_SHIFT (_MK_SHIFT_CONST(8)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_RUBIK_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_RANGE (8:8) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_SHIFT (_MK_SHIFT_CONST(9)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_RUBIK_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_RANGE (9:9) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_SHIFT (_MK_SHIFT_CONST(16)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_RANGE (16:16) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_SHIFT (_MK_SHIFT_CONST(17)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_RANGE (17:17) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_SHIFT (_MK_SHIFT_CONST(18)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_RANGE (18:18) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_SHIFT (_MK_SHIFT_CONST(19)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_RANGE (19:19) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_SHIFT (_MK_SHIFT_CONST(20)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CACC_DONE_SET0_SHIFT)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_RANGE (20:20) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_SHIFT (_MK_SHIFT_CONST(21)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CACC_DONE_SET1_SHIFT)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_RANGE (21:21) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_WOFFSET (0x0) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register GLB_S_INTR_STATUS_0 +#define GLB_S_INTR_STATUS_0 (_MK_ADDR_CONST(0xc)) +#define GLB_S_INTR_STATUS_0_SECURE (0x0) +#define GLB_S_INTR_STATUS_0_DUAL (0x0) +#define GLB_S_INTR_STATUS_0_SCR (0) +#define GLB_S_INTR_STATUS_0_WORD_COUNT (0x1) +#define GLB_S_INTR_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_READ_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x3f03ff)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_RANGE (0:0) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(1)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_RANGE (1:1) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(2)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_RANGE (2:2) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(3)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_RANGE (3:3) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(4)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_RANGE (4:4) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(5)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_RANGE (5:5) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(6)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_RANGE (6:6) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(7)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_RANGE (7:7) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(8)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_RANGE (8:8) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(9)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_RANGE (9:9) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(16)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, \ + GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_RANGE (16:16) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(17)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, \ + GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_RANGE (17:17) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(18)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, \ + GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_RANGE (18:18) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(19)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, \ + GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_RANGE (19:19) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_SHIFT (_MK_SHIFT_CONST(20)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_SHIFT)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_RANGE (20:20) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_SHIFT (_MK_SHIFT_CONST(21)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_FIELD \ + (_MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_SHIFT)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_RANGE (21:21) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_WOFFSET (0x0) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_DEFAULT (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register MCIF_CFG_RD_WEIGHT_0_0 +#define MCIF_CFG_RD_WEIGHT_0_0 (_MK_ADDR_CONST(0x2000)) +#define MCIF_CFG_RD_WEIGHT_0_0_SECURE (0x0) +#define MCIF_CFG_RD_WEIGHT_0_0_DUAL (0x0) +#define MCIF_CFG_RD_WEIGHT_0_0_SCR (0) +#define MCIF_CFG_RD_WEIGHT_0_0_WORD_COUNT (0x1) +#define MCIF_CFG_RD_WEIGHT_0_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define MCIF_CFG_RD_WEIGHT_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT (_MK_SHIFT_CONST(0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_RANGE (7:0) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT (_MK_SHIFT_CONST(8)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_RANGE (15:8) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT (_MK_SHIFT_CONST(16)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_RANGE (23:16) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT (_MK_SHIFT_CONST(24)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_RANGE (31:24) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register MCIF_CFG_RD_WEIGHT_1_0 +#define MCIF_CFG_RD_WEIGHT_1_0 (_MK_ADDR_CONST(0x2004)) +#define MCIF_CFG_RD_WEIGHT_1_0_SECURE (0x0) +#define MCIF_CFG_RD_WEIGHT_1_0_DUAL (0x0) +#define MCIF_CFG_RD_WEIGHT_1_0_SCR (0) +#define MCIF_CFG_RD_WEIGHT_1_0_WORD_COUNT (0x1) +#define MCIF_CFG_RD_WEIGHT_1_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define MCIF_CFG_RD_WEIGHT_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT (_MK_SHIFT_CONST(0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_RANGE (7:0) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT (_MK_SHIFT_CONST(8)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_RANGE (15:8) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT (_MK_SHIFT_CONST(16)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_RANGE (23:16) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT (_MK_SHIFT_CONST(24)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_FIELD \ + (_MK_FIELD_CONST(0xff, \ + MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_RANGE (31:24) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_DEFAULT \ + (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register MCIF_CFG_RD_WEIGHT_2_0 +#define MCIF_CFG_RD_WEIGHT_2_0 (_MK_ADDR_CONST(0x2008)) +#define MCIF_CFG_RD_WEIGHT_2_0_SECURE (0x0) +#define MCIF_CFG_RD_WEIGHT_2_0_DUAL (0x0) +#define MCIF_CFG_RD_WEIGHT_2_0_SCR (0) +#define MCIF_CFG_RD_WEIGHT_2_0_WORD_COUNT (0x1) +#define MCIF_CFG_RD_WEIGHT_2_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define MCIF_CFG_RD_WEIGHT_2_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_2_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_2_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT (_MK_SHIFT_CONST(0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_FIELD \ + (_MK_FIELD_CONST(0xff, \ + MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_RANGE (7:0) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_DEFAULT \ + (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT (_MK_SHIFT_CONST(8)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_RANGE (15:8) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT (_MK_SHIFT_CONST(16)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_RANGE (23:16) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT (_MK_SHIFT_CONST(24)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_RANGE (31:24) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_WOFFSET (0x0) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register MCIF_CFG_WR_WEIGHT_0_0 +#define MCIF_CFG_WR_WEIGHT_0_0 (_MK_ADDR_CONST(0x200c)) +#define MCIF_CFG_WR_WEIGHT_0_0_SECURE (0x0) +#define MCIF_CFG_WR_WEIGHT_0_0_DUAL (0x0) +#define MCIF_CFG_WR_WEIGHT_0_0_SCR (0) +#define MCIF_CFG_WR_WEIGHT_0_0_WORD_COUNT (0x1) +#define MCIF_CFG_WR_WEIGHT_0_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define MCIF_CFG_WR_WEIGHT_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_WR_WEIGHT_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_WR_WEIGHT_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT (_MK_SHIFT_CONST(0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_RANGE (7:0) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT (_MK_SHIFT_CONST(8)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_RANGE (15:8) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT (_MK_SHIFT_CONST(16)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_RANGE (23:16) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT (_MK_SHIFT_CONST(24)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_RANGE (31:24) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register MCIF_CFG_WR_WEIGHT_1_0 +#define MCIF_CFG_WR_WEIGHT_1_0 (_MK_ADDR_CONST(0x2010)) +#define MCIF_CFG_WR_WEIGHT_1_0_SECURE (0x0) +#define MCIF_CFG_WR_WEIGHT_1_0_DUAL (0x0) +#define MCIF_CFG_WR_WEIGHT_1_0_SCR (0) +#define MCIF_CFG_WR_WEIGHT_1_0_WORD_COUNT (0x1) +#define MCIF_CFG_WR_WEIGHT_1_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define MCIF_CFG_WR_WEIGHT_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_WR_WEIGHT_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_WR_WEIGHT_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT (_MK_SHIFT_CONST(0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_RANGE (7:0) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT (_MK_SHIFT_CONST(8)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_RANGE (15:8) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT (_MK_SHIFT_CONST(16)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_RANGE (23:16) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT (_MK_SHIFT_CONST(24)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_RANGE (31:24) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_WOFFSET (0x0) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register MCIF_CFG_OUTSTANDING_CNT_0 +#define MCIF_CFG_OUTSTANDING_CNT_0 (_MK_ADDR_CONST(0x2014)) +#define MCIF_CFG_OUTSTANDING_CNT_0_SECURE (0x0) +#define MCIF_CFG_OUTSTANDING_CNT_0_DUAL (0x0) +#define MCIF_CFG_OUTSTANDING_CNT_0_SCR (0) +#define MCIF_CFG_OUTSTANDING_CNT_0_WORD_COUNT (0x1) +#define MCIF_CFG_OUTSTANDING_CNT_0_RESET_VAL (_MK_MASK_CONST(0xffff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT (_MK_SHIFT_CONST(0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_RANGE (7:0) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_WOFFSET (0x0) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_DEFAULT (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT (_MK_SHIFT_CONST(8)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_FIELD \ + (_MK_FIELD_CONST(0xff, MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_RANGE (15:8) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_WOFFSET (0x0) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_DEFAULT (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register MCIF_STATUS_0 +#define MCIF_STATUS_0 (_MK_ADDR_CONST(0x2018)) +#define MCIF_STATUS_0_SECURE (0x0) +#define MCIF_STATUS_0_DUAL (0x0) +#define MCIF_STATUS_0_SCR (0) +#define MCIF_STATUS_0_WORD_COUNT (0x1) +#define MCIF_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x100)) +#define MCIF_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x100)) +#define MCIF_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define MCIF_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_STATUS_0_READ_MASK (_MK_MASK_CONST(0x100)) +#define MCIF_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_STATUS_0_IDLE_SHIFT (_MK_SHIFT_CONST(8)) +#define MCIF_STATUS_0_IDLE_FIELD \ + (_MK_FIELD_CONST(0x1, MCIF_STATUS_0_IDLE_SHIFT)) +#define MCIF_STATUS_0_IDLE_RANGE (8:8) +#define MCIF_STATUS_0_IDLE_WOFFSET (0x0) +#define MCIF_STATUS_0_IDLE_DEFAULT (_MK_MASK_CONST(0x1)) +#define MCIF_STATUS_0_IDLE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define MCIF_STATUS_0_IDLE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define MCIF_STATUS_0_IDLE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define MCIF_STATUS_0_IDLE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define MCIF_STATUS_0_IDLE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define MCIF_STATUS_0_IDLE_INIT_ENUM (YES) +#define MCIF_STATUS_0_IDLE_NO (_MK_ENUM_CONST(0)) +#define MCIF_STATUS_0_IDLE_YES (_MK_ENUM_CONST(1)) + + +// Register CVIF_CFG_RD_WEIGHT_0_0 +#define CVIF_CFG_RD_WEIGHT_0_0 (_MK_ADDR_CONST(0x3000)) +#define CVIF_CFG_RD_WEIGHT_0_0_SECURE (0x0) +#define CVIF_CFG_RD_WEIGHT_0_0_DUAL (0x0) +#define CVIF_CFG_RD_WEIGHT_0_0_SCR (0) +#define CVIF_CFG_RD_WEIGHT_0_0_WORD_COUNT (0x1) +#define CVIF_CFG_RD_WEIGHT_0_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define CVIF_CFG_RD_WEIGHT_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT (_MK_SHIFT_CONST(0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_RANGE (7:0) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT (_MK_SHIFT_CONST(8)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_RANGE (15:8) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT (_MK_SHIFT_CONST(16)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_RANGE (23:16) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT (_MK_SHIFT_CONST(24)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_RANGE (31:24) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CVIF_CFG_RD_WEIGHT_1_0 +#define CVIF_CFG_RD_WEIGHT_1_0 (_MK_ADDR_CONST(0x3004)) +#define CVIF_CFG_RD_WEIGHT_1_0_SECURE (0x0) +#define CVIF_CFG_RD_WEIGHT_1_0_DUAL (0x0) +#define CVIF_CFG_RD_WEIGHT_1_0_SCR (0) +#define CVIF_CFG_RD_WEIGHT_1_0_WORD_COUNT (0x1) +#define CVIF_CFG_RD_WEIGHT_1_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define CVIF_CFG_RD_WEIGHT_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT (_MK_SHIFT_CONST(0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_RANGE (7:0) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT (_MK_SHIFT_CONST(8)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_RANGE (15:8) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT (_MK_SHIFT_CONST(16)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_RANGE (23:16) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT (_MK_SHIFT_CONST(24)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_FIELD \ + (_MK_FIELD_CONST(0xff, \ + CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_RANGE (31:24) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_DEFAULT \ + (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CVIF_CFG_RD_WEIGHT_2_0 +#define CVIF_CFG_RD_WEIGHT_2_0 (_MK_ADDR_CONST(0x3008)) +#define CVIF_CFG_RD_WEIGHT_2_0_SECURE (0x0) +#define CVIF_CFG_RD_WEIGHT_2_0_DUAL (0x0) +#define CVIF_CFG_RD_WEIGHT_2_0_SCR (0) +#define CVIF_CFG_RD_WEIGHT_2_0_WORD_COUNT (0x1) +#define CVIF_CFG_RD_WEIGHT_2_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define CVIF_CFG_RD_WEIGHT_2_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_2_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_2_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT (_MK_SHIFT_CONST(0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_FIELD \ + (_MK_FIELD_CONST(0xff, \ + CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_RANGE (7:0) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_DEFAULT \ + (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT (_MK_SHIFT_CONST(8)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_RANGE (15:8) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_RANGE (23:16) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT (_MK_SHIFT_CONST(24)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_RANGE (31:24) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_WOFFSET (0x0) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CVIF_CFG_WR_WEIGHT_0_0 +#define CVIF_CFG_WR_WEIGHT_0_0 (_MK_ADDR_CONST(0x300c)) +#define CVIF_CFG_WR_WEIGHT_0_0_SECURE (0x0) +#define CVIF_CFG_WR_WEIGHT_0_0_DUAL (0x0) +#define CVIF_CFG_WR_WEIGHT_0_0_SCR (0) +#define CVIF_CFG_WR_WEIGHT_0_0_WORD_COUNT (0x1) +#define CVIF_CFG_WR_WEIGHT_0_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define CVIF_CFG_WR_WEIGHT_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_WR_WEIGHT_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_WR_WEIGHT_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT (_MK_SHIFT_CONST(0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_RANGE (7:0) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT (_MK_SHIFT_CONST(8)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_RANGE (15:8) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT (_MK_SHIFT_CONST(16)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_RANGE (23:16) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT (_MK_SHIFT_CONST(24)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_RANGE (31:24) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CVIF_CFG_WR_WEIGHT_1_0 +#define CVIF_CFG_WR_WEIGHT_1_0 (_MK_ADDR_CONST(0x3010)) +#define CVIF_CFG_WR_WEIGHT_1_0_SECURE (0x0) +#define CVIF_CFG_WR_WEIGHT_1_0_DUAL (0x0) +#define CVIF_CFG_WR_WEIGHT_1_0_SCR (0) +#define CVIF_CFG_WR_WEIGHT_1_0_WORD_COUNT (0x1) +#define CVIF_CFG_WR_WEIGHT_1_0_RESET_VAL (_MK_MASK_CONST(0x1010101)) +#define CVIF_CFG_WR_WEIGHT_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_WR_WEIGHT_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_WR_WEIGHT_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT (_MK_SHIFT_CONST(0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_RANGE (7:0) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT (_MK_SHIFT_CONST(8)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_RANGE (15:8) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_RANGE (23:16) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT (_MK_SHIFT_CONST(24)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_RANGE (31:24) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_WOFFSET (0x0) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CVIF_CFG_OUTSTANDING_CNT_0 +#define CVIF_CFG_OUTSTANDING_CNT_0 (_MK_ADDR_CONST(0x3014)) +#define CVIF_CFG_OUTSTANDING_CNT_0_SECURE (0x0) +#define CVIF_CFG_OUTSTANDING_CNT_0_DUAL (0x0) +#define CVIF_CFG_OUTSTANDING_CNT_0_SCR (0) +#define CVIF_CFG_OUTSTANDING_CNT_0_WORD_COUNT (0x1) +#define CVIF_CFG_OUTSTANDING_CNT_0_RESET_VAL (_MK_MASK_CONST(0xffff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT (_MK_SHIFT_CONST(0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_RANGE (7:0) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_WOFFSET (0x0) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_DEFAULT (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT (_MK_SHIFT_CONST(8)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_FIELD \ + (_MK_FIELD_CONST(0xff, CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_RANGE (15:8) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_WOFFSET (0x0) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_DEFAULT (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CVIF_STATUS_0 +#define CVIF_STATUS_0 (_MK_ADDR_CONST(0x3018)) +#define CVIF_STATUS_0_SECURE (0x0) +#define CVIF_STATUS_0_DUAL (0x0) +#define CVIF_STATUS_0_SCR (0) +#define CVIF_STATUS_0_WORD_COUNT (0x1) +#define CVIF_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x100)) +#define CVIF_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x100)) +#define CVIF_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CVIF_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_STATUS_0_READ_MASK (_MK_MASK_CONST(0x100)) +#define CVIF_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_STATUS_0_IDLE_SHIFT (_MK_SHIFT_CONST(8)) +#define CVIF_STATUS_0_IDLE_FIELD \ + (_MK_FIELD_CONST(0x1, CVIF_STATUS_0_IDLE_SHIFT)) +#define CVIF_STATUS_0_IDLE_RANGE (8:8) +#define CVIF_STATUS_0_IDLE_WOFFSET (0x0) +#define CVIF_STATUS_0_IDLE_DEFAULT (_MK_MASK_CONST(0x1)) +#define CVIF_STATUS_0_IDLE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CVIF_STATUS_0_IDLE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CVIF_STATUS_0_IDLE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CVIF_STATUS_0_IDLE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CVIF_STATUS_0_IDLE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CVIF_STATUS_0_IDLE_INIT_ENUM (YES) +#define CVIF_STATUS_0_IDLE_NO (_MK_ENUM_CONST(0)) +#define CVIF_STATUS_0_IDLE_YES (_MK_ENUM_CONST(1)) + + +// Register BDMA_CFG_SRC_ADDR_LOW_0 +#define BDMA_CFG_SRC_ADDR_LOW_0 (_MK_ADDR_CONST(0x4000)) +#define BDMA_CFG_SRC_ADDR_LOW_0_SECURE (0x0) +#define BDMA_CFG_SRC_ADDR_LOW_0_DUAL (0x0) +#define BDMA_CFG_SRC_ADDR_LOW_0_SCR (0) +#define BDMA_CFG_SRC_ADDR_LOW_0_WORD_COUNT (0x1) +#define BDMA_CFG_SRC_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_SHIFT (_MK_SHIFT_CONST(5)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, BDMA_CFG_SRC_ADDR_LOW_0_V32_SHIFT)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_RANGE (31:5) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_WOFFSET (0x0) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_DEFAULT_MASK (_MK_MASK_CONST(0x7ffffff)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_SRC_ADDR_HIGH_0 +#define BDMA_CFG_SRC_ADDR_HIGH_0 (_MK_ADDR_CONST(0x4004)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_SECURE (0x0) +#define BDMA_CFG_SRC_ADDR_HIGH_0_DUAL (0x0) +#define BDMA_CFG_SRC_ADDR_HIGH_0_SCR (0) +#define BDMA_CFG_SRC_ADDR_HIGH_0_WORD_COUNT (0x1) +#define BDMA_CFG_SRC_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_FIELD \ + (_MK_FIELD_CONST(0xffffffff, BDMA_CFG_SRC_ADDR_HIGH_0_V8_SHIFT)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_RANGE (31:0) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_WOFFSET (0x0) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_DST_ADDR_LOW_0 +#define BDMA_CFG_DST_ADDR_LOW_0 (_MK_ADDR_CONST(0x4008)) +#define BDMA_CFG_DST_ADDR_LOW_0_SECURE (0x0) +#define BDMA_CFG_DST_ADDR_LOW_0_DUAL (0x0) +#define BDMA_CFG_DST_ADDR_LOW_0_SCR (0) +#define BDMA_CFG_DST_ADDR_LOW_0_WORD_COUNT (0x1) +#define BDMA_CFG_DST_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_SHIFT (_MK_SHIFT_CONST(5)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, BDMA_CFG_DST_ADDR_LOW_0_V32_SHIFT)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_RANGE (31:5) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_WOFFSET (0x0) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_DEFAULT_MASK (_MK_MASK_CONST(0x7ffffff)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_DST_ADDR_HIGH_0 +#define BDMA_CFG_DST_ADDR_HIGH_0 (_MK_ADDR_CONST(0x400c)) +#define BDMA_CFG_DST_ADDR_HIGH_0_SECURE (0x0) +#define BDMA_CFG_DST_ADDR_HIGH_0_DUAL (0x0) +#define BDMA_CFG_DST_ADDR_HIGH_0_SCR (0) +#define BDMA_CFG_DST_ADDR_HIGH_0_WORD_COUNT (0x1) +#define BDMA_CFG_DST_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_DST_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_DST_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_FIELD \ + (_MK_FIELD_CONST(0xffffffff, BDMA_CFG_DST_ADDR_HIGH_0_V8_SHIFT)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_RANGE (31:0) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_WOFFSET (0x0) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_LINE_0 +#define BDMA_CFG_LINE_0 (_MK_ADDR_CONST(0x4010)) +#define BDMA_CFG_LINE_0_SECURE (0x0) +#define BDMA_CFG_LINE_0_DUAL (0x0) +#define BDMA_CFG_LINE_0_SCR (0) +#define BDMA_CFG_LINE_0_WORD_COUNT (0x1) +#define BDMA_CFG_LINE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define BDMA_CFG_LINE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define BDMA_CFG_LINE_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define BDMA_CFG_LINE_0_SIZE_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_LINE_0_SIZE_FIELD \ + (_MK_FIELD_CONST(0x1fff, BDMA_CFG_LINE_0_SIZE_SHIFT)) +#define BDMA_CFG_LINE_0_SIZE_RANGE (12:0) +#define BDMA_CFG_LINE_0_SIZE_WOFFSET (0x0) +#define BDMA_CFG_LINE_0_SIZE_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_0_SIZE_DEFAULT_MASK (_MK_MASK_CONST(0x1fff)) +#define BDMA_CFG_LINE_0_SIZE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_0_SIZE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_0_SIZE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_0_SIZE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_CMD_0 +#define BDMA_CFG_CMD_0 (_MK_ADDR_CONST(0x4014)) +#define BDMA_CFG_CMD_0_SECURE (0x0) +#define BDMA_CFG_CMD_0_DUAL (0x0) +#define BDMA_CFG_CMD_0_SCR (0) +#define BDMA_CFG_CMD_0_WORD_COUNT (0x1) +#define BDMA_CFG_CMD_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define BDMA_CFG_CMD_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define BDMA_CFG_CMD_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_CFG_CMD_0_SRC_RAM_TYPE_SHIFT)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_RANGE (0:0) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_WOFFSET (0x0) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_CVSRAM (_MK_ENUM_CONST(0)) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(1)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_CFG_CMD_0_DST_RAM_TYPE_SHIFT)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_RANGE (1:1) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_WOFFSET (0x0) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_CVSRAM (_MK_ENUM_CONST(0)) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register BDMA_CFG_LINE_REPEAT_0 +#define BDMA_CFG_LINE_REPEAT_0 (_MK_ADDR_CONST(0x4018)) +#define BDMA_CFG_LINE_REPEAT_0_SECURE (0x0) +#define BDMA_CFG_LINE_REPEAT_0_DUAL (0x0) +#define BDMA_CFG_LINE_REPEAT_0_SCR (0) +#define BDMA_CFG_LINE_REPEAT_0_WORD_COUNT (0x1) +#define BDMA_CFG_LINE_REPEAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_REPEAT_0_RESET_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_LINE_REPEAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_REPEAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_REPEAT_0_READ_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_LINE_REPEAT_0_WRITE_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_FIELD \ + (_MK_FIELD_CONST(0xffffff, BDMA_CFG_LINE_REPEAT_0_NUMBER_SHIFT)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_RANGE (23:0) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_WOFFSET (0x0) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_DEFAULT_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_SRC_LINE_0 +#define BDMA_CFG_SRC_LINE_0 (_MK_ADDR_CONST(0x401c)) +#define BDMA_CFG_SRC_LINE_0_SECURE (0x0) +#define BDMA_CFG_SRC_LINE_0_DUAL (0x0) +#define BDMA_CFG_SRC_LINE_0_SCR (0) +#define BDMA_CFG_SRC_LINE_0_WORD_COUNT (0x1) +#define BDMA_CFG_SRC_LINE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_LINE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_LINE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_LINE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_LINE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_LINE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, BDMA_CFG_SRC_LINE_0_STRIDE_SHIFT)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_RANGE (31:5) +#define BDMA_CFG_SRC_LINE_0_STRIDE_WOFFSET (0x0) +#define BDMA_CFG_SRC_LINE_0_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_DEFAULT_MASK (_MK_MASK_CONST(0x7ffffff)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_LINE_0_STRIDE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_DST_LINE_0 +#define BDMA_CFG_DST_LINE_0 (_MK_ADDR_CONST(0x4020)) +#define BDMA_CFG_DST_LINE_0_SECURE (0x0) +#define BDMA_CFG_DST_LINE_0_DUAL (0x0) +#define BDMA_CFG_DST_LINE_0_SCR (0) +#define BDMA_CFG_DST_LINE_0_WORD_COUNT (0x1) +#define BDMA_CFG_DST_LINE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_LINE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_LINE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_LINE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_LINE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_LINE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_LINE_0_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define BDMA_CFG_DST_LINE_0_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, BDMA_CFG_DST_LINE_0_STRIDE_SHIFT)) +#define BDMA_CFG_DST_LINE_0_STRIDE_RANGE (31:5) +#define BDMA_CFG_DST_LINE_0_STRIDE_WOFFSET (0x0) +#define BDMA_CFG_DST_LINE_0_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_LINE_0_STRIDE_DEFAULT_MASK (_MK_MASK_CONST(0x7ffffff)) +#define BDMA_CFG_DST_LINE_0_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_LINE_0_STRIDE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_LINE_0_STRIDE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_LINE_0_STRIDE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_SURF_REPEAT_0 +#define BDMA_CFG_SURF_REPEAT_0 (_MK_ADDR_CONST(0x4024)) +#define BDMA_CFG_SURF_REPEAT_0_SECURE (0x0) +#define BDMA_CFG_SURF_REPEAT_0_DUAL (0x0) +#define BDMA_CFG_SURF_REPEAT_0_SCR (0) +#define BDMA_CFG_SURF_REPEAT_0_WORD_COUNT (0x1) +#define BDMA_CFG_SURF_REPEAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SURF_REPEAT_0_RESET_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_SURF_REPEAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SURF_REPEAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SURF_REPEAT_0_READ_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_SURF_REPEAT_0_WRITE_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_FIELD \ + (_MK_FIELD_CONST(0xffffff, BDMA_CFG_SURF_REPEAT_0_NUMBER_SHIFT)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_RANGE (23:0) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_WOFFSET (0x0) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_DEFAULT_MASK (_MK_MASK_CONST(0xffffff)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_SRC_SURF_0 +#define BDMA_CFG_SRC_SURF_0 (_MK_ADDR_CONST(0x4028)) +#define BDMA_CFG_SRC_SURF_0_SECURE (0x0) +#define BDMA_CFG_SRC_SURF_0_DUAL (0x0) +#define BDMA_CFG_SRC_SURF_0_SCR (0) +#define BDMA_CFG_SRC_SURF_0_WORD_COUNT (0x1) +#define BDMA_CFG_SRC_SURF_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_SURF_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_SURF_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_SURF_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_SURF_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_SURF_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, BDMA_CFG_SRC_SURF_0_STRIDE_SHIFT)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_RANGE (31:5) +#define BDMA_CFG_SRC_SURF_0_STRIDE_WOFFSET (0x0) +#define BDMA_CFG_SRC_SURF_0_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_DEFAULT_MASK (_MK_MASK_CONST(0x7ffffff)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_SRC_SURF_0_STRIDE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_DST_SURF_0 +#define BDMA_CFG_DST_SURF_0 (_MK_ADDR_CONST(0x402c)) +#define BDMA_CFG_DST_SURF_0_SECURE (0x0) +#define BDMA_CFG_DST_SURF_0_DUAL (0x0) +#define BDMA_CFG_DST_SURF_0_SCR (0) +#define BDMA_CFG_DST_SURF_0_WORD_COUNT (0x1) +#define BDMA_CFG_DST_SURF_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_SURF_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_SURF_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_SURF_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_SURF_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_SURF_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define BDMA_CFG_DST_SURF_0_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define BDMA_CFG_DST_SURF_0_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, BDMA_CFG_DST_SURF_0_STRIDE_SHIFT)) +#define BDMA_CFG_DST_SURF_0_STRIDE_RANGE (31:5) +#define BDMA_CFG_DST_SURF_0_STRIDE_WOFFSET (0x0) +#define BDMA_CFG_DST_SURF_0_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_SURF_0_STRIDE_DEFAULT_MASK (_MK_MASK_CONST(0x7ffffff)) +#define BDMA_CFG_DST_SURF_0_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_SURF_0_STRIDE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_SURF_0_STRIDE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_DST_SURF_0_STRIDE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register BDMA_CFG_OP_0 +#define BDMA_CFG_OP_0 (_MK_ADDR_CONST(0x4030)) +#define BDMA_CFG_OP_0_SECURE (0x0) +#define BDMA_CFG_OP_0_DUAL (0x0) +#define BDMA_CFG_OP_0_SCR (0) +#define BDMA_CFG_OP_0_WORD_COUNT (0x1) +#define BDMA_CFG_OP_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_OP_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_OP_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_OP_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_OP_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_OP_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_OP_0_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_OP_0_EN_FIELD (_MK_FIELD_CONST(0x1, BDMA_CFG_OP_0_EN_SHIFT)) +#define BDMA_CFG_OP_0_EN_RANGE (0:0) +#define BDMA_CFG_OP_0_EN_WOFFSET (0x0) +#define BDMA_CFG_OP_0_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_OP_0_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_OP_0_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_OP_0_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_OP_0_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_OP_0_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_OP_0_EN_DISABLE (_MK_ENUM_CONST(0)) +#define BDMA_CFG_OP_0_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register BDMA_CFG_LAUNCH0_0 +#define BDMA_CFG_LAUNCH0_0 (_MK_ADDR_CONST(0x4034)) +#define BDMA_CFG_LAUNCH0_0_SECURE (0x0) +#define BDMA_CFG_LAUNCH0_0_DUAL (0x0) +#define BDMA_CFG_LAUNCH0_0_SCR (0) +#define BDMA_CFG_LAUNCH0_0_WORD_COUNT (0x1) +#define BDMA_CFG_LAUNCH0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH0_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH0_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH0_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_SHIFT)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_RANGE (0:0) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_WOFFSET (0x0) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_NO (_MK_ENUM_CONST(0)) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_YES (_MK_ENUM_CONST(1)) + + +// Register BDMA_CFG_LAUNCH1_0 +#define BDMA_CFG_LAUNCH1_0 (_MK_ADDR_CONST(0x4038)) +#define BDMA_CFG_LAUNCH1_0_SECURE (0x0) +#define BDMA_CFG_LAUNCH1_0_DUAL (0x0) +#define BDMA_CFG_LAUNCH1_0_SCR (0) +#define BDMA_CFG_LAUNCH1_0_WORD_COUNT (0x1) +#define BDMA_CFG_LAUNCH1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH1_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH1_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH1_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_SHIFT)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_RANGE (0:0) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_WOFFSET (0x0) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_NO (_MK_ENUM_CONST(0)) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_YES (_MK_ENUM_CONST(1)) + + +// Register BDMA_CFG_STATUS_0 +#define BDMA_CFG_STATUS_0 (_MK_ADDR_CONST(0x403c)) +#define BDMA_CFG_STATUS_0_SECURE (0x0) +#define BDMA_CFG_STATUS_0_DUAL (0x0) +#define BDMA_CFG_STATUS_0_SCR (0) +#define BDMA_CFG_STATUS_0_WORD_COUNT (0x1) +#define BDMA_CFG_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_STATUS_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_CFG_STATUS_0_STALL_COUNT_EN_SHIFT)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_RANGE (0:0) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_WOFFSET (0x0) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_INIT_ENUM (NO) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_NO (_MK_ENUM_CONST(0)) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_YES (_MK_ENUM_CONST(1)) + + +// Register BDMA_STATUS_0 +#define BDMA_STATUS_0 (_MK_ADDR_CONST(0x4040)) +#define BDMA_STATUS_0_SECURE (0x0) +#define BDMA_STATUS_0_DUAL (0x0) +#define BDMA_STATUS_0_SCR (0) +#define BDMA_STATUS_0_WORD_COUNT (0x1) +#define BDMA_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x114)) +#define BDMA_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x7ff)) +#define BDMA_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_READ_MASK (_MK_MASK_CONST(0x7ff)) +#define BDMA_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_FREE_SLOT_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_STATUS_0_FREE_SLOT_FIELD \ + (_MK_FIELD_CONST(0xff, BDMA_STATUS_0_FREE_SLOT_SHIFT)) +#define BDMA_STATUS_0_FREE_SLOT_RANGE (7:0) +#define BDMA_STATUS_0_FREE_SLOT_WOFFSET (0x0) +#define BDMA_STATUS_0_FREE_SLOT_DEFAULT (_MK_MASK_CONST(0x14)) +#define BDMA_STATUS_0_FREE_SLOT_DEFAULT_MASK (_MK_MASK_CONST(0xff)) +#define BDMA_STATUS_0_FREE_SLOT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_FREE_SLOT_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_FREE_SLOT_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_FREE_SLOT_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + +#define BDMA_STATUS_0_IDLE_SHIFT (_MK_SHIFT_CONST(8)) +#define BDMA_STATUS_0_IDLE_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_STATUS_0_IDLE_SHIFT)) +#define BDMA_STATUS_0_IDLE_RANGE (8:8) +#define BDMA_STATUS_0_IDLE_WOFFSET (0x0) +#define BDMA_STATUS_0_IDLE_DEFAULT (_MK_MASK_CONST(0x1)) +#define BDMA_STATUS_0_IDLE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_STATUS_0_IDLE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_IDLE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_IDLE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_IDLE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define BDMA_STATUS_0_IDLE_INIT_ENUM (YES) +#define BDMA_STATUS_0_IDLE_NO (_MK_ENUM_CONST(0)) +#define BDMA_STATUS_0_IDLE_YES (_MK_ENUM_CONST(1)) + +#define BDMA_STATUS_0_GRP0_BUSY_SHIFT (_MK_SHIFT_CONST(9)) +#define BDMA_STATUS_0_GRP0_BUSY_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_STATUS_0_GRP0_BUSY_SHIFT)) +#define BDMA_STATUS_0_GRP0_BUSY_RANGE (9:9) +#define BDMA_STATUS_0_GRP0_BUSY_WOFFSET (0x0) +#define BDMA_STATUS_0_GRP0_BUSY_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP0_BUSY_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_STATUS_0_GRP0_BUSY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP0_BUSY_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP0_BUSY_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP0_BUSY_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define BDMA_STATUS_0_GRP0_BUSY_INIT_ENUM (NO) +#define BDMA_STATUS_0_GRP0_BUSY_NO (_MK_ENUM_CONST(0)) +#define BDMA_STATUS_0_GRP0_BUSY_YES (_MK_ENUM_CONST(1)) + +#define BDMA_STATUS_0_GRP1_BUSY_SHIFT (_MK_SHIFT_CONST(10)) +#define BDMA_STATUS_0_GRP1_BUSY_FIELD \ + (_MK_FIELD_CONST(0x1, BDMA_STATUS_0_GRP1_BUSY_SHIFT)) +#define BDMA_STATUS_0_GRP1_BUSY_RANGE (10:10) +#define BDMA_STATUS_0_GRP1_BUSY_WOFFSET (0x0) +#define BDMA_STATUS_0_GRP1_BUSY_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP1_BUSY_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define BDMA_STATUS_0_GRP1_BUSY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP1_BUSY_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP1_BUSY_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_0_GRP1_BUSY_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define BDMA_STATUS_0_GRP1_BUSY_INIT_ENUM (NO) +#define BDMA_STATUS_0_GRP1_BUSY_NO (_MK_ENUM_CONST(0)) +#define BDMA_STATUS_0_GRP1_BUSY_YES (_MK_ENUM_CONST(1)) + + +// Register BDMA_STATUS_GRP0_READ_STALL_0 +#define BDMA_STATUS_GRP0_READ_STALL_0 (_MK_ADDR_CONST(0x4044)) +#define BDMA_STATUS_GRP0_READ_STALL_0_SECURE (0x0) +#define BDMA_STATUS_GRP0_READ_STALL_0_DUAL (0x0) +#define BDMA_STATUS_GRP0_READ_STALL_0_SCR (0) +#define BDMA_STATUS_GRP0_READ_STALL_0_WORD_COUNT (0x1) +#define BDMA_STATUS_GRP0_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP0_READ_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP0_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + BDMA_STATUS_GRP0_READ_STALL_0_COUNT_SHIFT)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_RANGE (31:0) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_WOFFSET (0x0) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register BDMA_STATUS_GRP0_WRITE_STALL_0 +#define BDMA_STATUS_GRP0_WRITE_STALL_0 (_MK_ADDR_CONST(0x4048)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_SECURE (0x0) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_DUAL (0x0) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_SCR (0) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_WORD_COUNT (0x1) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_SHIFT)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_RANGE (31:0) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_WOFFSET (0x0) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register BDMA_STATUS_GRP1_READ_STALL_0 +#define BDMA_STATUS_GRP1_READ_STALL_0 (_MK_ADDR_CONST(0x404c)) +#define BDMA_STATUS_GRP1_READ_STALL_0_SECURE (0x0) +#define BDMA_STATUS_GRP1_READ_STALL_0_DUAL (0x0) +#define BDMA_STATUS_GRP1_READ_STALL_0_SCR (0) +#define BDMA_STATUS_GRP1_READ_STALL_0_WORD_COUNT (0x1) +#define BDMA_STATUS_GRP1_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP1_READ_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP1_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + BDMA_STATUS_GRP1_READ_STALL_0_COUNT_SHIFT)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_RANGE (31:0) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_WOFFSET (0x0) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register BDMA_STATUS_GRP1_WRITE_STALL_0 +#define BDMA_STATUS_GRP1_WRITE_STALL_0 (_MK_ADDR_CONST(0x4050)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_SECURE (0x0) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_DUAL (0x0) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_SCR (0) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_WORD_COUNT (0x1) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_SHIFT (_MK_SHIFT_CONST(0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_SHIFT)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_RANGE (31:0) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_WOFFSET (0x0) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_S_STATUS_0 +#define CDMA_S_STATUS_0 (_MK_ADDR_CONST(0x5000)) +#define CDMA_S_STATUS_0_SECURE (0x0) +#define CDMA_S_STATUS_0_DUAL (0x0) +#define CDMA_S_STATUS_0_SCR (0) +#define CDMA_S_STATUS_0_WORD_COUNT (0x1) +#define CDMA_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define CDMA_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define CDMA_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, CDMA_S_STATUS_0_STATUS_0_SHIFT)) +#define CDMA_S_STATUS_0_STATUS_0_RANGE (1:0) +#define CDMA_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define CDMA_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDMA_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define CDMA_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define CDMA_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define CDMA_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define CDMA_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, CDMA_S_STATUS_0_STATUS_1_SHIFT)) +#define CDMA_S_STATUS_0_STATUS_1_RANGE (17:16) +#define CDMA_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define CDMA_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDMA_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define CDMA_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define CDMA_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define CDMA_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register CDMA_S_POINTER_0 +#define CDMA_S_POINTER_0 (_MK_ADDR_CONST(0x5004)) +#define CDMA_S_POINTER_0_SECURE (0x0) +#define CDMA_S_POINTER_0_DUAL (0x0) +#define CDMA_S_POINTER_0_SCR (0) +#define CDMA_S_POINTER_0_WORD_COUNT (0x1) +#define CDMA_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CDMA_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CDMA_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_S_POINTER_0_PRODUCER_SHIFT)) +#define CDMA_S_POINTER_0_PRODUCER_RANGE (0:0) +#define CDMA_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define CDMA_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define CDMA_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CDMA_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define CDMA_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_S_POINTER_0_CONSUMER_SHIFT)) +#define CDMA_S_POINTER_0_CONSUMER_RANGE (16:16) +#define CDMA_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define CDMA_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define CDMA_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CDMA_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register CDMA_S_ARBITER_0 +#define CDMA_S_ARBITER_0 (_MK_ADDR_CONST(0x5008)) +#define CDMA_S_ARBITER_0_SECURE (0x0) +#define CDMA_S_ARBITER_0_DUAL (0x0) +#define CDMA_S_ARBITER_0_SCR (0) +#define CDMA_S_ARBITER_0_WORD_COUNT (0x1) +#define CDMA_S_ARBITER_0_RESET_VAL (_MK_MASK_CONST(0x3000f)) +#define CDMA_S_ARBITER_0_RESET_MASK (_MK_MASK_CONST(0xf000f)) +#define CDMA_S_ARBITER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_READ_MASK (_MK_MASK_CONST(0xf000f)) +#define CDMA_S_ARBITER_0_WRITE_MASK (_MK_MASK_CONST(0xf000f)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_FIELD \ + (_MK_FIELD_CONST(0xf, CDMA_S_ARBITER_0_ARB_WEIGHT_SHIFT)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_RANGE (3:0) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_WOFFSET (0x0) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_DEFAULT (_MK_MASK_CONST(0xf)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_DEFAULT_MASK (_MK_MASK_CONST(0xf)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + +#define CDMA_S_ARBITER_0_ARB_WMB_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_S_ARBITER_0_ARB_WMB_FIELD \ + (_MK_FIELD_CONST(0xf, CDMA_S_ARBITER_0_ARB_WMB_SHIFT)) +#define CDMA_S_ARBITER_0_ARB_WMB_RANGE (19:16) +#define CDMA_S_ARBITER_0_ARB_WMB_WOFFSET (0x0) +#define CDMA_S_ARBITER_0_ARB_WMB_DEFAULT (_MK_MASK_CONST(0x3)) +#define CDMA_S_ARBITER_0_ARB_WMB_DEFAULT_MASK (_MK_MASK_CONST(0xf)) +#define CDMA_S_ARBITER_0_ARB_WMB_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_ARB_WMB_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_ARB_WMB_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_S_ARBITER_0_ARB_WMB_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDMA_S_CBUF_FLUSH_STATUS_0 +#define CDMA_S_CBUF_FLUSH_STATUS_0 (_MK_ADDR_CONST(0x500c)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_SECURE (0x0) +#define CDMA_S_CBUF_FLUSH_STATUS_0_DUAL (0x0) +#define CDMA_S_CBUF_FLUSH_STATUS_0_SCR (0) +#define CDMA_S_CBUF_FLUSH_STATUS_0_WORD_COUNT (0x1) +#define CDMA_S_CBUF_FLUSH_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_SHIFT)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_RANGE (0:0) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_WOFFSET (0x0) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_OP_ENABLE_0 +#define CDMA_D_OP_ENABLE_0 (_MK_ADDR_CONST(0x5010)) +#define CDMA_D_OP_ENABLE_0_SECURE (0x0) +#define CDMA_D_OP_ENABLE_0_DUAL (0x0) +#define CDMA_D_OP_ENABLE_0_SCR (0) +#define CDMA_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define CDMA_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define CDMA_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define CDMA_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define CDMA_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define CDMA_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_MISC_CFG_0 +#define CDMA_D_MISC_CFG_0 (_MK_ADDR_CONST(0x5014)) +#define CDMA_D_MISC_CFG_0_SECURE (0x0) +#define CDMA_D_MISC_CFG_0_DUAL (0x0) +#define CDMA_D_MISC_CFG_0_SCR (0) +#define CDMA_D_MISC_CFG_0_WORD_COUNT (0x1) +#define CDMA_D_MISC_CFG_0_RESET_VAL (_MK_MASK_CONST(0x1100)) +#define CDMA_D_MISC_CFG_0_RESET_MASK (_MK_MASK_CONST(0x11113301)) +#define CDMA_D_MISC_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_READ_MASK (_MK_MASK_CONST(0x11113301)) +#define CDMA_D_MISC_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x11113301)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_CONV_MODE_SHIFT)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_RANGE (0:0) +#define CDMA_D_MISC_CFG_0_CONV_MODE_WOFFSET (0x0) +#define CDMA_D_MISC_CFG_0_CONV_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_INIT_ENUM (DIRECT) +#define CDMA_D_MISC_CFG_0_CONV_MODE_DIRECT (_MK_ENUM_CONST(0)) +#define CDMA_D_MISC_CFG_0_CONV_MODE_WINOGRAD (_MK_ENUM_CONST(1)) + +#define CDMA_D_MISC_CFG_0_IN_PRECISION_SHIFT (_MK_SHIFT_CONST(8)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, CDMA_D_MISC_CFG_0_IN_PRECISION_SHIFT)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_RANGE (9:8) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_WOFFSET (0x0) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_INIT_ENUM (INT16) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_SHIFT (_MK_SHIFT_CONST(12)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, CDMA_D_MISC_CFG_0_PROC_PRECISION_SHIFT)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_RANGE (13:12) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_WOFFSET (0x0) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_INIT_ENUM (INT16) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define CDMA_D_MISC_CFG_0_DATA_REUSE_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_DATA_REUSE_SHIFT)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_RANGE (16:16) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_WOFFSET (0x0) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_INIT_ENUM (DISABLE) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_ENABLE (_MK_ENUM_CONST(1)) + +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT (_MK_SHIFT_CONST(20)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_RANGE (20:20) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_WOFFSET (0x0) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_INIT_ENUM (DISABLE) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_ENABLE (_MK_ENUM_CONST(1)) + +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT (_MK_SHIFT_CONST(24)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_RANGE (24:24) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_WOFFSET (0x0) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_INIT_ENUM (DISABLE) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_ENABLE (_MK_ENUM_CONST(1)) + +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT (_MK_SHIFT_CONST(28)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_RANGE (28:28) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_WOFFSET (0x0) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_INIT_ENUM (DISABLE) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_DATAIN_FORMAT_0 +#define CDMA_D_DATAIN_FORMAT_0 (_MK_ADDR_CONST(0x5018)) +#define CDMA_D_DATAIN_FORMAT_0_SECURE (0x0) +#define CDMA_D_DATAIN_FORMAT_0_DUAL (0x0) +#define CDMA_D_DATAIN_FORMAT_0_SCR (0) +#define CDMA_D_DATAIN_FORMAT_0_WORD_COUNT (0x1) +#define CDMA_D_DATAIN_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0xc00)) +#define CDMA_D_DATAIN_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x113f01)) +#define CDMA_D_DATAIN_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x113f01)) +#define CDMA_D_DATAIN_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x113f01)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_RANGE (0:0) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_WOFFSET (0x0) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_INIT_ENUM (FEATURE) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FEATURE (_MK_ENUM_CONST(0)) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PIXEL (_MK_ENUM_CONST(1)) + +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_SHIFT (_MK_SHIFT_CONST(8)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_FIELD \ + (_MK_FIELD_CONST(0x3f, CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_SHIFT)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_RANGE (13:8) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_WOFFSET (0x0) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_DEFAULT (_MK_MASK_CONST(0xc)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_INIT_ENUM (T_A8B8G8R8) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R8 (_MK_ENUM_CONST(0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R10 (_MK_ENUM_CONST(1)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R12 (_MK_ENUM_CONST(2)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R16 (_MK_ENUM_CONST(3)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R16_I (_MK_ENUM_CONST(4)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R16_F (_MK_ENUM_CONST(5)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16B16G16R16 \ + (_MK_ENUM_CONST(6)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_X16B16G16R16 \ + (_MK_ENUM_CONST(7)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16B16G16R16_F \ + (_MK_ENUM_CONST(8)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16Y16U16V16 \ + (_MK_ENUM_CONST(9)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_V16U16Y16A16 \ + (_MK_ENUM_CONST(10)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16Y16U16V16_F \ + (_MK_ENUM_CONST(11)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A8B8G8R8 (_MK_ENUM_CONST(12)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A8R8G8B8 (_MK_ENUM_CONST(13)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_B8G8R8A8 (_MK_ENUM_CONST(14)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R8G8B8A8 (_MK_ENUM_CONST(15)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_X8B8G8R8 (_MK_ENUM_CONST(16)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_X8R8G8B8 (_MK_ENUM_CONST(17)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_B8G8R8X8 (_MK_ENUM_CONST(18)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R8G8B8X8 (_MK_ENUM_CONST(19)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A2B10G10R10 \ + (_MK_ENUM_CONST(20)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A2R10G10B10 \ + (_MK_ENUM_CONST(21)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_B10G10R10A2 \ + (_MK_ENUM_CONST(22)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R10G10B10A2 \ + (_MK_ENUM_CONST(23)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A2Y10U10V10 \ + (_MK_ENUM_CONST(24)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_V10U10Y10A2 \ + (_MK_ENUM_CONST(25)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A8Y8U8V8 (_MK_ENUM_CONST(26)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_V8U8Y8A8 (_MK_ENUM_CONST(27)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y8___U8V8_N444 \ + (_MK_ENUM_CONST(28)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y8___V8U8_N444 \ + (_MK_ENUM_CONST(29)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y10___U10V10_N444 \ + (_MK_ENUM_CONST(30)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y10___V10U10_N444 \ + (_MK_ENUM_CONST(31)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y12___U12V12_N444 \ + (_MK_ENUM_CONST(32)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y12___V12U12_N444 \ + (_MK_ENUM_CONST(33)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y16___U16V16_N444 \ + (_MK_ENUM_CONST(34)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y16___V16U16_N444 \ + (_MK_ENUM_CONST(35)) + +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_SHIFT)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_RANGE (16:16) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_WOFFSET (0x0) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_INIT_ENUM (PITCH_LINEAR) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_PITCH_LINEAR (_MK_ENUM_CONST(0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_RESERVED_LINEAR \ + (_MK_ENUM_CONST(1)) + +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SHIFT \ + (_MK_SHIFT_CONST(20)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_FIELD \ + (_MK_FIELD_CONST(0x1, \ + CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SHIFT)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_RANGE (20:20) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_WOFFSET (0x0) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_INIT_ENUM (UNSIGNED_INT) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_UNSIGNED_INT \ + (_MK_ENUM_CONST(0)) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SIGNED_INT \ + (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_DATAIN_SIZE_0_0 +#define CDMA_D_DATAIN_SIZE_0_0 (_MK_ADDR_CONST(0x501c)) +#define CDMA_D_DATAIN_SIZE_0_0_SECURE (0x0) +#define CDMA_D_DATAIN_SIZE_0_0_DUAL (0x0) +#define CDMA_D_DATAIN_SIZE_0_0_SCR (0) +#define CDMA_D_DATAIN_SIZE_0_0_WORD_COUNT (0x1) +#define CDMA_D_DATAIN_SIZE_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_RESET_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CDMA_D_DATAIN_SIZE_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_READ_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CDMA_D_DATAIN_SIZE_0_0_WRITE_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_RANGE (12:0) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_WOFFSET (0x0) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_RANGE (28:16) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_WOFFSET (0x0) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_DATAIN_SIZE_1_0 +#define CDMA_D_DATAIN_SIZE_1_0 (_MK_ADDR_CONST(0x5020)) +#define CDMA_D_DATAIN_SIZE_1_0_SECURE (0x0) +#define CDMA_D_DATAIN_SIZE_1_0_DUAL (0x0) +#define CDMA_D_DATAIN_SIZE_1_0_SCR (0) +#define CDMA_D_DATAIN_SIZE_1_0_WORD_COUNT (0x1) +#define CDMA_D_DATAIN_SIZE_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_1_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_RANGE (12:0) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_WOFFSET (0x0) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_DATAIN_SIZE_EXT_0_0 +#define CDMA_D_DATAIN_SIZE_EXT_0_0 (_MK_ADDR_CONST(0x5024)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_SECURE (0x0) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DUAL (0x0) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_SCR (0) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_WORD_COUNT (0x1) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_RESET_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_READ_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_WRITE_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_RANGE (12:0) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_WOFFSET (0x0) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_RANGE (28:16) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_WOFFSET (0x0) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_PIXEL_OFFSET_0 +#define CDMA_D_PIXEL_OFFSET_0 (_MK_ADDR_CONST(0x5028)) +#define CDMA_D_PIXEL_OFFSET_0_SECURE (0x0) +#define CDMA_D_PIXEL_OFFSET_0_DUAL (0x0) +#define CDMA_D_PIXEL_OFFSET_0_SCR (0) +#define CDMA_D_PIXEL_OFFSET_0_WORD_COUNT (0x1) +#define CDMA_D_PIXEL_OFFSET_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_RESET_MASK (_MK_MASK_CONST(0x7001f)) +#define CDMA_D_PIXEL_OFFSET_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_READ_MASK (_MK_MASK_CONST(0x7001f)) +#define CDMA_D_PIXEL_OFFSET_0_WRITE_MASK (_MK_MASK_CONST(0x7001f)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_FIELD \ + (_MK_FIELD_CONST(0x1f, CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_SHIFT)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_RANGE (4:0) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_WOFFSET (0x0) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_FIELD \ + (_MK_FIELD_CONST(0x7, CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_SHIFT)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_RANGE (18:16) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_WOFFSET (0x0) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_DAIN_RAM_TYPE_0 +#define CDMA_D_DAIN_RAM_TYPE_0 (_MK_ADDR_CONST(0x502c)) +#define CDMA_D_DAIN_RAM_TYPE_0_SECURE (0x0) +#define CDMA_D_DAIN_RAM_TYPE_0_DUAL (0x0) +#define CDMA_D_DAIN_RAM_TYPE_0_SCR (0) +#define CDMA_D_DAIN_RAM_TYPE_0_WORD_COUNT (0x1) +#define CDMA_D_DAIN_RAM_TYPE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_RAM_TYPE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_RAM_TYPE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_RAM_TYPE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_RAM_TYPE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_RAM_TYPE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_RANGE (0:0) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_WOFFSET (0x0) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_INIT_ENUM (CVIF) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_CVIF (_MK_ENUM_CONST(0)) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_MCIF (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_DAIN_ADDR_HIGH_0_0 +#define CDMA_D_DAIN_ADDR_HIGH_0_0 (_MK_ADDR_CONST(0x5030)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_SECURE (0x0) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DUAL (0x0) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_SCR (0) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_WORD_COUNT (0x1) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_SHIFT)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_RANGE (31:0) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_WOFFSET (0x0) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_DAIN_ADDR_LOW_0_0 +#define CDMA_D_DAIN_ADDR_LOW_0_0 (_MK_ADDR_CONST(0x5034)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_SECURE (0x0) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DUAL (0x0) +#define CDMA_D_DAIN_ADDR_LOW_0_0_SCR (0) +#define CDMA_D_DAIN_ADDR_LOW_0_0_WORD_COUNT (0x1) +#define CDMA_D_DAIN_ADDR_LOW_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_SHIFT)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_RANGE (31:5) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_WOFFSET (0x0) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_DAIN_ADDR_HIGH_1_0 +#define CDMA_D_DAIN_ADDR_HIGH_1_0 (_MK_ADDR_CONST(0x5038)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_SECURE (0x0) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DUAL (0x0) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_SCR (0) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_WORD_COUNT (0x1) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_SHIFT)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_RANGE (31:0) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_WOFFSET (0x0) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_DAIN_ADDR_LOW_1_0 +#define CDMA_D_DAIN_ADDR_LOW_1_0 (_MK_ADDR_CONST(0x503c)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_SECURE (0x0) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DUAL (0x0) +#define CDMA_D_DAIN_ADDR_LOW_1_0_SCR (0) +#define CDMA_D_DAIN_ADDR_LOW_1_0_WORD_COUNT (0x1) +#define CDMA_D_DAIN_ADDR_LOW_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_SHIFT)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_RANGE (31:5) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_WOFFSET (0x0) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_LINE_STRIDE_0 +#define CDMA_D_LINE_STRIDE_0 (_MK_ADDR_CONST(0x5040)) +#define CDMA_D_LINE_STRIDE_0_SECURE (0x0) +#define CDMA_D_LINE_STRIDE_0_DUAL (0x0) +#define CDMA_D_LINE_STRIDE_0_SCR (0) +#define CDMA_D_LINE_STRIDE_0_WORD_COUNT (0x1) +#define CDMA_D_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, CDMA_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_RANGE (31:5) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_WOFFSET (0x0) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_LINE_UV_STRIDE_0 +#define CDMA_D_LINE_UV_STRIDE_0 (_MK_ADDR_CONST(0x5044)) +#define CDMA_D_LINE_UV_STRIDE_0_SECURE (0x0) +#define CDMA_D_LINE_UV_STRIDE_0_DUAL (0x0) +#define CDMA_D_LINE_UV_STRIDE_0_SCR (0) +#define CDMA_D_LINE_UV_STRIDE_0_WORD_COUNT (0x1) +#define CDMA_D_LINE_UV_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_UV_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_LINE_UV_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_UV_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_UV_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_LINE_UV_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_SHIFT)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_RANGE (31:5) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_WOFFSET (0x0) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_SURF_STRIDE_0 +#define CDMA_D_SURF_STRIDE_0 (_MK_ADDR_CONST(0x5048)) +#define CDMA_D_SURF_STRIDE_0_SECURE (0x0) +#define CDMA_D_SURF_STRIDE_0_DUAL (0x0) +#define CDMA_D_SURF_STRIDE_0_SCR (0) +#define CDMA_D_SURF_STRIDE_0_WORD_COUNT (0x1) +#define CDMA_D_SURF_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_SURF_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_SURF_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_SURF_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_SURF_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_SURF_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, CDMA_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_RANGE (31:5) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_WOFFSET (0x0) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_DAIN_MAP_0 +#define CDMA_D_DAIN_MAP_0 (_MK_ADDR_CONST(0x504c)) +#define CDMA_D_DAIN_MAP_0_SECURE (0x0) +#define CDMA_D_DAIN_MAP_0_DUAL (0x0) +#define CDMA_D_DAIN_MAP_0_SCR (0) +#define CDMA_D_DAIN_MAP_0_WORD_COUNT (0x1) +#define CDMA_D_DAIN_MAP_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CDMA_D_DAIN_MAP_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CDMA_D_DAIN_MAP_0_WRITE_MASK (_MK_MASK_CONST(0x10001)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_DAIN_MAP_0_LINE_PACKED_SHIFT)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_RANGE (0:0) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_WOFFSET (0x0) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_INIT_ENUM (FALSE) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_FALSE (_MK_ENUM_CONST(0)) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_TRUE (_MK_ENUM_CONST(1)) + +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_DAIN_MAP_0_SURF_PACKED_SHIFT)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_RANGE (16:16) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_WOFFSET (0x0) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_INIT_ENUM (FALSE) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_FALSE (_MK_ENUM_CONST(0)) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_TRUE (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_RESERVED_X_CFG_0 +#define CDMA_D_RESERVED_X_CFG_0 (_MK_ADDR_CONST(0x5050)) +#define CDMA_D_RESERVED_X_CFG_0_SECURE (0x0) +#define CDMA_D_RESERVED_X_CFG_0_DUAL (0x0) +#define CDMA_D_RESERVED_X_CFG_0_SCR (0) +#define CDMA_D_RESERVED_X_CFG_0_WORD_COUNT (0x1) +#define CDMA_D_RESERVED_X_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3ff03ff)) +#define CDMA_D_RESERVED_X_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_READ_MASK (_MK_MASK_CONST(0x3ff03ff)) +#define CDMA_D_RESERVED_X_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3ff03ff)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_FIELD \ + (_MK_FIELD_CONST(0x3ff, CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_SHIFT)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_RANGE (9:0) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_WOFFSET (0x0) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_SHIFT)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_RANGE (25:16) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_WOFFSET (0x0) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_RESERVED_Y_CFG_0 +#define CDMA_D_RESERVED_Y_CFG_0 (_MK_ADDR_CONST(0x5054)) +#define CDMA_D_RESERVED_Y_CFG_0_SECURE (0x0) +#define CDMA_D_RESERVED_Y_CFG_0_DUAL (0x0) +#define CDMA_D_RESERVED_Y_CFG_0_SCR (0) +#define CDMA_D_RESERVED_Y_CFG_0_WORD_COUNT (0x1) +#define CDMA_D_RESERVED_Y_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1f0007)) +#define CDMA_D_RESERVED_Y_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_READ_MASK (_MK_MASK_CONST(0x1f0007)) +#define CDMA_D_RESERVED_Y_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1f0007)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x7, CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_SHIFT)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_RANGE (2:0) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_WOFFSET (0x0) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_DEFAULT_MASK (_MK_MASK_CONST(0x7)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_FIELD \ + (_MK_FIELD_CONST(0x1f, CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_SHIFT)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_RANGE (20:16) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_WOFFSET (0x0) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_BATCH_NUMBER_0 +#define CDMA_D_BATCH_NUMBER_0 (_MK_ADDR_CONST(0x5058)) +#define CDMA_D_BATCH_NUMBER_0_SECURE (0x0) +#define CDMA_D_BATCH_NUMBER_0_DUAL (0x0) +#define CDMA_D_BATCH_NUMBER_0_SCR (0) +#define CDMA_D_BATCH_NUMBER_0_WORD_COUNT (0x1) +#define CDMA_D_BATCH_NUMBER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_NUMBER_0_RESET_MASK (_MK_MASK_CONST(0x1f)) +#define CDMA_D_BATCH_NUMBER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_NUMBER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_NUMBER_0_READ_MASK (_MK_MASK_CONST(0x1f)) +#define CDMA_D_BATCH_NUMBER_0_WRITE_MASK (_MK_MASK_CONST(0x1f)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_FIELD \ + (_MK_FIELD_CONST(0x1f, CDMA_D_BATCH_NUMBER_0_BATCHES_SHIFT)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_RANGE (4:0) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_WOFFSET (0x0) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_BATCH_STRIDE_0 +#define CDMA_D_BATCH_STRIDE_0 (_MK_ADDR_CONST(0x505c)) +#define CDMA_D_BATCH_STRIDE_0_SECURE (0x0) +#define CDMA_D_BATCH_STRIDE_0_DUAL (0x0) +#define CDMA_D_BATCH_STRIDE_0_SCR (0) +#define CDMA_D_BATCH_STRIDE_0_WORD_COUNT (0x1) +#define CDMA_D_BATCH_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_BATCH_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_BATCH_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_SHIFT)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_RANGE (31:5) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_WOFFSET (0x0) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_ENTRY_PER_SLICE_0 +#define CDMA_D_ENTRY_PER_SLICE_0 (_MK_ADDR_CONST(0x5060)) +#define CDMA_D_ENTRY_PER_SLICE_0_SECURE (0x0) +#define CDMA_D_ENTRY_PER_SLICE_0_DUAL (0x0) +#define CDMA_D_ENTRY_PER_SLICE_0_SCR (0) +#define CDMA_D_ENTRY_PER_SLICE_0_WORD_COUNT (0x1) +#define CDMA_D_ENTRY_PER_SLICE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_ENTRY_PER_SLICE_0_RESET_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_ENTRY_PER_SLICE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_ENTRY_PER_SLICE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_ENTRY_PER_SLICE_0_READ_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_ENTRY_PER_SLICE_0_WRITE_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_FIELD \ + (_MK_FIELD_CONST(0xfff, CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_RANGE (11:0) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_WOFFSET (0x0) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_DEFAULT_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_FETCH_GRAIN_0 +#define CDMA_D_FETCH_GRAIN_0 (_MK_ADDR_CONST(0x5064)) +#define CDMA_D_FETCH_GRAIN_0_SECURE (0x0) +#define CDMA_D_FETCH_GRAIN_0_DUAL (0x0) +#define CDMA_D_FETCH_GRAIN_0_SCR (0) +#define CDMA_D_FETCH_GRAIN_0_WORD_COUNT (0x1) +#define CDMA_D_FETCH_GRAIN_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_FETCH_GRAIN_0_RESET_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_FETCH_GRAIN_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_FETCH_GRAIN_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_FETCH_GRAIN_0_READ_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_FETCH_GRAIN_0_WRITE_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_FIELD \ + (_MK_FIELD_CONST(0xfff, CDMA_D_FETCH_GRAIN_0_GRAINS_SHIFT)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_RANGE (11:0) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_WOFFSET (0x0) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_DEFAULT_MASK (_MK_MASK_CONST(0xfff)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WEIGHT_FORMAT_0 +#define CDMA_D_WEIGHT_FORMAT_0 (_MK_ADDR_CONST(0x5068)) +#define CDMA_D_WEIGHT_FORMAT_0_SECURE (0x0) +#define CDMA_D_WEIGHT_FORMAT_0_DUAL (0x0) +#define CDMA_D_WEIGHT_FORMAT_0_SCR (0) +#define CDMA_D_WEIGHT_FORMAT_0_WORD_COUNT (0x1) +#define CDMA_D_WEIGHT_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_RANGE (0:0) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_WOFFSET (0x0) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_INIT_ENUM (UNCOMPRESSED) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_UNCOMPRESSED (_MK_ENUM_CONST(0)) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_COMPRESSED (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_WEIGHT_SIZE_0_0 +#define CDMA_D_WEIGHT_SIZE_0_0 (_MK_ADDR_CONST(0x506c)) +#define CDMA_D_WEIGHT_SIZE_0_0_SECURE (0x0) +#define CDMA_D_WEIGHT_SIZE_0_0_DUAL (0x0) +#define CDMA_D_WEIGHT_SIZE_0_0_SCR (0) +#define CDMA_D_WEIGHT_SIZE_0_0_WORD_COUNT (0x1) +#define CDMA_D_WEIGHT_SIZE_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_0_0_RESET_MASK (_MK_MASK_CONST(0x3ffff)) +#define CDMA_D_WEIGHT_SIZE_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_0_0_READ_MASK (_MK_MASK_CONST(0x3ffff)) +#define CDMA_D_WEIGHT_SIZE_0_0_WRITE_MASK (_MK_MASK_CONST(0x3ffff)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_FIELD \ + (_MK_FIELD_CONST(0x3ffff, \ + CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_SHIFT)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_RANGE (17:0) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_WOFFSET (0x0) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ffff)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WEIGHT_SIZE_1_0 +#define CDMA_D_WEIGHT_SIZE_1_0 (_MK_ADDR_CONST(0x5070)) +#define CDMA_D_WEIGHT_SIZE_1_0_SECURE (0x0) +#define CDMA_D_WEIGHT_SIZE_1_0_DUAL (0x0) +#define CDMA_D_WEIGHT_SIZE_1_0_SCR (0) +#define CDMA_D_WEIGHT_SIZE_1_0_WORD_COUNT (0x1) +#define CDMA_D_WEIGHT_SIZE_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_WEIGHT_SIZE_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_1_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_WEIGHT_SIZE_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_SHIFT)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_RANGE (12:0) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_WOFFSET (0x0) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WEIGHT_RAM_TYPE_0 +#define CDMA_D_WEIGHT_RAM_TYPE_0 (_MK_ADDR_CONST(0x5074)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_SECURE (0x0) +#define CDMA_D_WEIGHT_RAM_TYPE_0_DUAL (0x0) +#define CDMA_D_WEIGHT_RAM_TYPE_0_SCR (0) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WORD_COUNT (0x1) +#define CDMA_D_WEIGHT_RAM_TYPE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, \ + CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_SHIFT)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_RANGE (0:0) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_WOFFSET (0x0) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_INIT_ENUM (CVIF) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_CVIF (_MK_ENUM_CONST(0)) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_MCIF (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_WEIGHT_ADDR_HIGH_0 +#define CDMA_D_WEIGHT_ADDR_HIGH_0 (_MK_ADDR_CONST(0x5078)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_SECURE (0x0) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_DUAL (0x0) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_SCR (0) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WORD_COUNT (0x1) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_SHIFT)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_RANGE (31:0) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_WOFFSET (0x0) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WEIGHT_ADDR_LOW_0 +#define CDMA_D_WEIGHT_ADDR_LOW_0 (_MK_ADDR_CONST(0x507c)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_SECURE (0x0) +#define CDMA_D_WEIGHT_ADDR_LOW_0_DUAL (0x0) +#define CDMA_D_WEIGHT_ADDR_LOW_0_SCR (0) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WORD_COUNT (0x1) +#define CDMA_D_WEIGHT_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_SHIFT)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_RANGE (31:5) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_WOFFSET (0x0) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WEIGHT_BYTES_0 +#define CDMA_D_WEIGHT_BYTES_0 (_MK_ADDR_CONST(0x5080)) +#define CDMA_D_WEIGHT_BYTES_0_SECURE (0x0) +#define CDMA_D_WEIGHT_BYTES_0_DUAL (0x0) +#define CDMA_D_WEIGHT_BYTES_0_SCR (0) +#define CDMA_D_WEIGHT_BYTES_0_WORD_COUNT (0x1) +#define CDMA_D_WEIGHT_BYTES_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_BYTES_0_RESET_MASK (_MK_MASK_CONST(0xffffff80)) +#define CDMA_D_WEIGHT_BYTES_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_BYTES_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_BYTES_0_READ_MASK (_MK_MASK_CONST(0xffffff80)) +#define CDMA_D_WEIGHT_BYTES_0_WRITE_MASK (_MK_MASK_CONST(0xffffff80)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT (_MK_SHIFT_CONST(7)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_FIELD \ + (_MK_FIELD_CONST(0x1ffffff, \ + CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_RANGE (31:7) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_WOFFSET (0x0) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1ffffff)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WGS_ADDR_HIGH_0 +#define CDMA_D_WGS_ADDR_HIGH_0 (_MK_ADDR_CONST(0x5084)) +#define CDMA_D_WGS_ADDR_HIGH_0_SECURE (0x0) +#define CDMA_D_WGS_ADDR_HIGH_0_DUAL (0x0) +#define CDMA_D_WGS_ADDR_HIGH_0_SCR (0) +#define CDMA_D_WGS_ADDR_HIGH_0_WORD_COUNT (0x1) +#define CDMA_D_WGS_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WGS_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WGS_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_SHIFT)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_RANGE (31:0) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_WOFFSET (0x0) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WGS_ADDR_LOW_0 +#define CDMA_D_WGS_ADDR_LOW_0 (_MK_ADDR_CONST(0x5088)) +#define CDMA_D_WGS_ADDR_LOW_0_SECURE (0x0) +#define CDMA_D_WGS_ADDR_LOW_0_DUAL (0x0) +#define CDMA_D_WGS_ADDR_LOW_0_SCR (0) +#define CDMA_D_WGS_ADDR_LOW_0_WORD_COUNT (0x1) +#define CDMA_D_WGS_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WGS_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WGS_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_SHIFT)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_RANGE (31:5) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_WOFFSET (0x0) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WMB_ADDR_HIGH_0 +#define CDMA_D_WMB_ADDR_HIGH_0 (_MK_ADDR_CONST(0x508c)) +#define CDMA_D_WMB_ADDR_HIGH_0_SECURE (0x0) +#define CDMA_D_WMB_ADDR_HIGH_0_DUAL (0x0) +#define CDMA_D_WMB_ADDR_HIGH_0_SCR (0) +#define CDMA_D_WMB_ADDR_HIGH_0_WORD_COUNT (0x1) +#define CDMA_D_WMB_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WMB_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WMB_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_SHIFT)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_RANGE (31:0) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_WOFFSET (0x0) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WMB_ADDR_LOW_0 +#define CDMA_D_WMB_ADDR_LOW_0 (_MK_ADDR_CONST(0x5090)) +#define CDMA_D_WMB_ADDR_LOW_0_SECURE (0x0) +#define CDMA_D_WMB_ADDR_LOW_0_DUAL (0x0) +#define CDMA_D_WMB_ADDR_LOW_0_SCR (0) +#define CDMA_D_WMB_ADDR_LOW_0_WORD_COUNT (0x1) +#define CDMA_D_WMB_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WMB_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WMB_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_SHIFT (_MK_SHIFT_CONST(5)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_SHIFT)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_RANGE (31:5) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_WOFFSET (0x0) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_WMB_BYTES_0 +#define CDMA_D_WMB_BYTES_0 (_MK_ADDR_CONST(0x5094)) +#define CDMA_D_WMB_BYTES_0_SECURE (0x0) +#define CDMA_D_WMB_BYTES_0_DUAL (0x0) +#define CDMA_D_WMB_BYTES_0_SCR (0) +#define CDMA_D_WMB_BYTES_0_WORD_COUNT (0x1) +#define CDMA_D_WMB_BYTES_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_BYTES_0_RESET_MASK (_MK_MASK_CONST(0xfffff80)) +#define CDMA_D_WMB_BYTES_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_BYTES_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_BYTES_0_READ_MASK (_MK_MASK_CONST(0xfffff80)) +#define CDMA_D_WMB_BYTES_0_WRITE_MASK (_MK_MASK_CONST(0xfffff80)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_SHIFT (_MK_SHIFT_CONST(7)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_FIELD \ + (_MK_FIELD_CONST(0x1fffff, CDMA_D_WMB_BYTES_0_WMB_BYTES_SHIFT)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_RANGE (27:7) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_WOFFSET (0x0) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_DEFAULT_MASK (_MK_MASK_CONST(0x1fffff)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_MEAN_FORMAT_0 +#define CDMA_D_MEAN_FORMAT_0 (_MK_ADDR_CONST(0x5098)) +#define CDMA_D_MEAN_FORMAT_0_SECURE (0x0) +#define CDMA_D_MEAN_FORMAT_0_DUAL (0x0) +#define CDMA_D_MEAN_FORMAT_0_SCR (0) +#define CDMA_D_MEAN_FORMAT_0_WORD_COUNT (0x1) +#define CDMA_D_MEAN_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MEAN_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MEAN_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_SHIFT)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_RANGE (0:0) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_WOFFSET (0x0) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_INIT_ENUM (DISABLE) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_MEAN_GLOBAL_0_0 +#define CDMA_D_MEAN_GLOBAL_0_0 (_MK_ADDR_CONST(0x509c)) +#define CDMA_D_MEAN_GLOBAL_0_0_SECURE (0x0) +#define CDMA_D_MEAN_GLOBAL_0_0_DUAL (0x0) +#define CDMA_D_MEAN_GLOBAL_0_0_SCR (0) +#define CDMA_D_MEAN_GLOBAL_0_0_WORD_COUNT (0x1) +#define CDMA_D_MEAN_GLOBAL_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_MEAN_GLOBAL_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_MEAN_GLOBAL_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_FIELD \ + (_MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_SHIFT)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_RANGE (15:0) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_WOFFSET (0x0) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_FIELD \ + (_MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_SHIFT)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_RANGE (31:16) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_WOFFSET (0x0) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_MEAN_GLOBAL_1_0 +#define CDMA_D_MEAN_GLOBAL_1_0 (_MK_ADDR_CONST(0x50a0)) +#define CDMA_D_MEAN_GLOBAL_1_0_SECURE (0x0) +#define CDMA_D_MEAN_GLOBAL_1_0_DUAL (0x0) +#define CDMA_D_MEAN_GLOBAL_1_0_SCR (0) +#define CDMA_D_MEAN_GLOBAL_1_0_WORD_COUNT (0x1) +#define CDMA_D_MEAN_GLOBAL_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_MEAN_GLOBAL_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_MEAN_GLOBAL_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_FIELD \ + (_MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_SHIFT)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_RANGE (15:0) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_WOFFSET (0x0) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_FIELD \ + (_MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_SHIFT)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_RANGE (31:16) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_WOFFSET (0x0) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_CVT_CFG_0 +#define CDMA_D_CVT_CFG_0 (_MK_ADDR_CONST(0x50a4)) +#define CDMA_D_CVT_CFG_0_SECURE (0x0) +#define CDMA_D_CVT_CFG_0_DUAL (0x0) +#define CDMA_D_CVT_CFG_0_SCR (0) +#define CDMA_D_CVT_CFG_0_WORD_COUNT (0x1) +#define CDMA_D_CVT_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3f1)) +#define CDMA_D_CVT_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_READ_MASK (_MK_MASK_CONST(0x3f1)) +#define CDMA_D_CVT_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3f1)) +#define CDMA_D_CVT_CFG_0_CVT_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_CVT_CFG_0_CVT_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_CVT_CFG_0_CVT_EN_SHIFT)) +#define CDMA_D_CVT_CFG_0_CVT_EN_RANGE (0:0) +#define CDMA_D_CVT_CFG_0_CVT_EN_WOFFSET (0x0) +#define CDMA_D_CVT_CFG_0_CVT_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_CVT_CFG_0_CVT_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDMA_D_CVT_CFG_0_CVT_EN_INIT_ENUM (DISABLE) +#define CDMA_D_CVT_CFG_0_CVT_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_CVT_CFG_0_CVT_EN_ENABLE (_MK_ENUM_CONST(1)) + +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_SHIFT (_MK_SHIFT_CONST(4)) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_FIELD \ + (_MK_FIELD_CONST(0x3f, CDMA_D_CVT_CFG_0_CVT_TRUNCATE_SHIFT)) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_RANGE (9:4) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_WOFFSET (0x0) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_DEFAULT_MASK (_MK_MASK_CONST(0x3f)) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_CVT_OFFSET_0 +#define CDMA_D_CVT_OFFSET_0 (_MK_ADDR_CONST(0x50a8)) +#define CDMA_D_CVT_OFFSET_0_SECURE (0x0) +#define CDMA_D_CVT_OFFSET_0_DUAL (0x0) +#define CDMA_D_CVT_OFFSET_0_SCR (0) +#define CDMA_D_CVT_OFFSET_0_WORD_COUNT (0x1) +#define CDMA_D_CVT_OFFSET_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_OFFSET_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_OFFSET_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_OFFSET_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_OFFSET_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_OFFSET_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xffff, CDMA_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_RANGE (15:0) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_WOFFSET (0x0) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_CVT_SCALE_0 +#define CDMA_D_CVT_SCALE_0 (_MK_ADDR_CONST(0x50ac)) +#define CDMA_D_CVT_SCALE_0_SECURE (0x0) +#define CDMA_D_CVT_SCALE_0_DUAL (0x0) +#define CDMA_D_CVT_SCALE_0_SCR (0) +#define CDMA_D_CVT_SCALE_0_WORD_COUNT (0x1) +#define CDMA_D_CVT_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, CDMA_D_CVT_SCALE_0_CVT_SCALE_SHIFT)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_RANGE (15:0) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_WOFFSET (0x0) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_CONV_STRIDE_0 +#define CDMA_D_CONV_STRIDE_0 (_MK_ADDR_CONST(0x50b0)) +#define CDMA_D_CONV_STRIDE_0_SECURE (0x0) +#define CDMA_D_CONV_STRIDE_0_DUAL (0x0) +#define CDMA_D_CONV_STRIDE_0_SCR (0) +#define CDMA_D_CONV_STRIDE_0_WORD_COUNT (0x1) +#define CDMA_D_CONV_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0x70007)) +#define CDMA_D_CONV_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_READ_MASK (_MK_MASK_CONST(0x70007)) +#define CDMA_D_CONV_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0x70007)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7, CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_SHIFT)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_RANGE (2:0) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_WOFFSET (0x0) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_DEFAULT_MASK (_MK_MASK_CONST(0x7)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7, CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_SHIFT)) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_RANGE (18:16) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_WOFFSET (0x0) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_DEFAULT_MASK (_MK_MASK_CONST(0x7)) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_ZERO_PADDING_0 +#define CDMA_D_ZERO_PADDING_0 (_MK_ADDR_CONST(0x50b4)) +#define CDMA_D_ZERO_PADDING_0_SECURE (0x0) +#define CDMA_D_ZERO_PADDING_0_DUAL (0x0) +#define CDMA_D_ZERO_PADDING_0_SCR (0) +#define CDMA_D_ZERO_PADDING_0_WORD_COUNT (0x1) +#define CDMA_D_ZERO_PADDING_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_RESET_MASK (_MK_MASK_CONST(0x3f1f3f1f)) +#define CDMA_D_ZERO_PADDING_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_READ_MASK (_MK_MASK_CONST(0x3f1f3f1f)) +#define CDMA_D_ZERO_PADDING_0_WRITE_MASK (_MK_MASK_CONST(0x3f1f3f1f)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_FIELD \ + (_MK_FIELD_CONST(0x1f, CDMA_D_ZERO_PADDING_0_PAD_LEFT_SHIFT)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_RANGE (4:0) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_WOFFSET (0x0) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_SHIFT (_MK_SHIFT_CONST(8)) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_FIELD \ + (_MK_FIELD_CONST(0x3f, CDMA_D_ZERO_PADDING_0_PAD_RIGHT_SHIFT)) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_RANGE (13:8) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_WOFFSET (0x0) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_DEFAULT_MASK (_MK_MASK_CONST(0x3f)) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_FIELD \ + (_MK_FIELD_CONST(0x1f, CDMA_D_ZERO_PADDING_0_PAD_TOP_SHIFT)) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_RANGE (20:16) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_WOFFSET (0x0) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_SHIFT (_MK_SHIFT_CONST(24)) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_FIELD \ + (_MK_FIELD_CONST(0x3f, CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_SHIFT)) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_RANGE (29:24) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_WOFFSET (0x0) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_DEFAULT_MASK (_MK_MASK_CONST(0x3f)) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_ZERO_PADDING_VALUE_0 +#define CDMA_D_ZERO_PADDING_VALUE_0 (_MK_ADDR_CONST(0x50b8)) +#define CDMA_D_ZERO_PADDING_VALUE_0_SECURE (0x0) +#define CDMA_D_ZERO_PADDING_VALUE_0_DUAL (0x0) +#define CDMA_D_ZERO_PADDING_VALUE_0_SCR (0) +#define CDMA_D_ZERO_PADDING_VALUE_0_WORD_COUNT (0x1) +#define CDMA_D_ZERO_PADDING_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_ZERO_PADDING_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_ZERO_PADDING_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_RANGE (15:0) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_WOFFSET (0x0) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_BANK_0 +#define CDMA_D_BANK_0 (_MK_ADDR_CONST(0x50bc)) +#define CDMA_D_BANK_0_SECURE (0x0) +#define CDMA_D_BANK_0_DUAL (0x0) +#define CDMA_D_BANK_0_SCR (0) +#define CDMA_D_BANK_0_WORD_COUNT (0x1) +#define CDMA_D_BANK_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_RESET_MASK (_MK_MASK_CONST(0xf000f)) +#define CDMA_D_BANK_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_READ_MASK (_MK_MASK_CONST(0xf000f)) +#define CDMA_D_BANK_0_WRITE_MASK (_MK_MASK_CONST(0xf000f)) +#define CDMA_D_BANK_0_DATA_BANK_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_BANK_0_DATA_BANK_FIELD \ + (_MK_FIELD_CONST(0xf, CDMA_D_BANK_0_DATA_BANK_SHIFT)) +#define CDMA_D_BANK_0_DATA_BANK_RANGE (3:0) +#define CDMA_D_BANK_0_DATA_BANK_WOFFSET (0x0) +#define CDMA_D_BANK_0_DATA_BANK_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_DATA_BANK_DEFAULT_MASK (_MK_MASK_CONST(0xf)) +#define CDMA_D_BANK_0_DATA_BANK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_DATA_BANK_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_DATA_BANK_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_DATA_BANK_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + +#define CDMA_D_BANK_0_WEIGHT_BANK_SHIFT (_MK_SHIFT_CONST(16)) +#define CDMA_D_BANK_0_WEIGHT_BANK_FIELD \ + (_MK_FIELD_CONST(0xf, CDMA_D_BANK_0_WEIGHT_BANK_SHIFT)) +#define CDMA_D_BANK_0_WEIGHT_BANK_RANGE (19:16) +#define CDMA_D_BANK_0_WEIGHT_BANK_WOFFSET (0x0) +#define CDMA_D_BANK_0_WEIGHT_BANK_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_WEIGHT_BANK_DEFAULT_MASK (_MK_MASK_CONST(0xf)) +#define CDMA_D_BANK_0_WEIGHT_BANK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_WEIGHT_BANK_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_WEIGHT_BANK_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_BANK_0_WEIGHT_BANK_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_NAN_FLUSH_TO_ZERO_0 +#define CDMA_D_NAN_FLUSH_TO_ZERO_0 (_MK_ADDR_CONST(0x50c0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_SECURE (0x0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_DUAL (0x0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_SCR (0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_WORD_COUNT (0x1) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_RANGE (0:0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_WOFFSET (0x0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_INIT_ENUM (DISABLE) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DISABLE (_MK_ENUM_CONST(0)) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDMA_D_NAN_INPUT_DATA_NUM_0 +#define CDMA_D_NAN_INPUT_DATA_NUM_0 (_MK_ADDR_CONST(0x50c4)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_SECURE (0x0) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_DUAL (0x0) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_SCR (0) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_WORD_COUNT (0x1) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_SHIFT)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_RANGE (31:0) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_WOFFSET (0x0) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_NAN_INPUT_WEIGHT_NUM_0 +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0 (_MK_ADDR_CONST(0x50c8)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_SECURE (0x0) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_DUAL (0x0) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_SCR (0) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_WORD_COUNT (0x1) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_SHIFT)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_RANGE (31:0) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_WOFFSET (0x0) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_INF_INPUT_DATA_NUM_0 +#define CDMA_D_INF_INPUT_DATA_NUM_0 (_MK_ADDR_CONST(0x50cc)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_SECURE (0x0) +#define CDMA_D_INF_INPUT_DATA_NUM_0_DUAL (0x0) +#define CDMA_D_INF_INPUT_DATA_NUM_0_SCR (0) +#define CDMA_D_INF_INPUT_DATA_NUM_0_WORD_COUNT (0x1) +#define CDMA_D_INF_INPUT_DATA_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_SHIFT)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_RANGE (31:0) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_WOFFSET (0x0) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_INF_INPUT_WEIGHT_NUM_0 +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0 (_MK_ADDR_CONST(0x50d0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_SECURE (0x0) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_DUAL (0x0) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_SCR (0) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_WORD_COUNT (0x1) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_SHIFT)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_RANGE (31:0) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_WOFFSET (0x0) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_PERF_ENABLE_0 +#define CDMA_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0x50d4)) +#define CDMA_D_PERF_ENABLE_0_SECURE (0x0) +#define CDMA_D_PERF_ENABLE_0_DUAL (0x0) +#define CDMA_D_PERF_ENABLE_0_SCR (0) +#define CDMA_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define CDMA_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_RANGE (0:0) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_WOFFSET (0x0) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_PERF_DAT_READ_STALL_0 +#define CDMA_D_PERF_DAT_READ_STALL_0 (_MK_ADDR_CONST(0x50d8)) +#define CDMA_D_PERF_DAT_READ_STALL_0_SECURE (0x0) +#define CDMA_D_PERF_DAT_READ_STALL_0_DUAL (0x0) +#define CDMA_D_PERF_DAT_READ_STALL_0_SCR (0) +#define CDMA_D_PERF_DAT_READ_STALL_0_WORD_COUNT (0x1) +#define CDMA_D_PERF_DAT_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_DAT_READ_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_DAT_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_SHIFT)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_RANGE (31:0) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_WOFFSET (0x0) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_PERF_WT_READ_STALL_0 +#define CDMA_D_PERF_WT_READ_STALL_0 (_MK_ADDR_CONST(0x50dc)) +#define CDMA_D_PERF_WT_READ_STALL_0_SECURE (0x0) +#define CDMA_D_PERF_WT_READ_STALL_0_DUAL (0x0) +#define CDMA_D_PERF_WT_READ_STALL_0_SCR (0) +#define CDMA_D_PERF_WT_READ_STALL_0_WORD_COUNT (0x1) +#define CDMA_D_PERF_WT_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_WT_READ_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_WT_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_SHIFT)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_RANGE (31:0) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_WOFFSET (0x0) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_PERF_DAT_READ_LATENCY_0 +#define CDMA_D_PERF_DAT_READ_LATENCY_0 (_MK_ADDR_CONST(0x50e0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_SECURE (0x0) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DUAL (0x0) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_SCR (0) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_WORD_COUNT (0x1) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_SHIFT)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_RANGE (31:0) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_WOFFSET (0x0) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_PERF_WT_READ_LATENCY_0 +#define CDMA_D_PERF_WT_READ_LATENCY_0 (_MK_ADDR_CONST(0x50e4)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_SECURE (0x0) +#define CDMA_D_PERF_WT_READ_LATENCY_0_DUAL (0x0) +#define CDMA_D_PERF_WT_READ_LATENCY_0_SCR (0) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WORD_COUNT (0x1) +#define CDMA_D_PERF_WT_READ_LATENCY_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_SHIFT)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_RANGE (31:0) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_WOFFSET (0x0) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDMA_D_CYA_0 +#define CDMA_D_CYA_0 (_MK_ADDR_CONST(0x50e8)) +#define CDMA_D_CYA_0_SECURE (0x0) +#define CDMA_D_CYA_0_DUAL (0x0) +#define CDMA_D_CYA_0_SCR (0) +#define CDMA_D_CYA_0_WORD_COUNT (0x1) +#define CDMA_D_CYA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CYA_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_CYA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDMA_D_CYA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CYA_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_CYA_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_CYA_0_CYA_SHIFT (_MK_SHIFT_CONST(0)) +#define CDMA_D_CYA_0_CYA_FIELD \ + (_MK_FIELD_CONST(0xffffffff, CDMA_D_CYA_0_CYA_SHIFT)) +#define CDMA_D_CYA_0_CYA_RANGE (31:0) +#define CDMA_D_CYA_0_CYA_WOFFSET (0x0) +#define CDMA_D_CYA_0_CYA_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CYA_0_CYA_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDMA_D_CYA_0_CYA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDMA_D_CYA_0_CYA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDMA_D_CYA_0_CYA_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDMA_D_CYA_0_CYA_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_S_STATUS_0 +#define CSC_S_STATUS_0 (_MK_ADDR_CONST(0x6000)) +#define CSC_S_STATUS_0_SECURE (0x0) +#define CSC_S_STATUS_0_DUAL (0x0) +#define CSC_S_STATUS_0_SCR (0) +#define CSC_S_STATUS_0_WORD_COUNT (0x1) +#define CSC_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define CSC_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define CSC_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, CSC_S_STATUS_0_STATUS_0_SHIFT)) +#define CSC_S_STATUS_0_STATUS_0_RANGE (1:0) +#define CSC_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define CSC_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CSC_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CSC_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define CSC_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define CSC_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define CSC_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define CSC_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, CSC_S_STATUS_0_STATUS_1_SHIFT)) +#define CSC_S_STATUS_0_STATUS_1_RANGE (17:16) +#define CSC_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define CSC_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CSC_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CSC_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define CSC_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define CSC_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define CSC_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register CSC_S_POINTER_0 +#define CSC_S_POINTER_0 (_MK_ADDR_CONST(0x6004)) +#define CSC_S_POINTER_0_SECURE (0x0) +#define CSC_S_POINTER_0_DUAL (0x0) +#define CSC_S_POINTER_0_SCR (0) +#define CSC_S_POINTER_0_WORD_COUNT (0x1) +#define CSC_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CSC_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CSC_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CSC_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_S_POINTER_0_PRODUCER_SHIFT)) +#define CSC_S_POINTER_0_PRODUCER_RANGE (0:0) +#define CSC_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define CSC_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CSC_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define CSC_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CSC_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define CSC_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_S_POINTER_0_CONSUMER_SHIFT)) +#define CSC_S_POINTER_0_CONSUMER_RANGE (16:16) +#define CSC_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define CSC_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CSC_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define CSC_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CSC_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register CSC_D_OP_ENABLE_0 +#define CSC_D_OP_ENABLE_0 (_MK_ADDR_CONST(0x6008)) +#define CSC_D_OP_ENABLE_0_SECURE (0x0) +#define CSC_D_OP_ENABLE_0_DUAL (0x0) +#define CSC_D_OP_ENABLE_0_SCR (0) +#define CSC_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define CSC_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define CSC_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define CSC_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define CSC_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CSC_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define CSC_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CSC_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CSC_D_MISC_CFG_0 +#define CSC_D_MISC_CFG_0 (_MK_ADDR_CONST(0x600c)) +#define CSC_D_MISC_CFG_0_SECURE (0x0) +#define CSC_D_MISC_CFG_0_DUAL (0x0) +#define CSC_D_MISC_CFG_0_SCR (0) +#define CSC_D_MISC_CFG_0_WORD_COUNT (0x1) +#define CSC_D_MISC_CFG_0_RESET_VAL (_MK_MASK_CONST(0x1100)) +#define CSC_D_MISC_CFG_0_RESET_MASK (_MK_MASK_CONST(0x11113301)) +#define CSC_D_MISC_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_READ_MASK (_MK_MASK_CONST(0x11113301)) +#define CSC_D_MISC_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x11113301)) +#define CSC_D_MISC_CFG_0_CONV_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_MISC_CFG_0_CONV_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_CONV_MODE_SHIFT)) +#define CSC_D_MISC_CFG_0_CONV_MODE_RANGE (0:0) +#define CSC_D_MISC_CFG_0_CONV_MODE_WOFFSET (0x0) +#define CSC_D_MISC_CFG_0_CONV_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_CONV_MODE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_CONV_MODE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_CONV_MODE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_CONV_MODE_INIT_ENUM (DIRECT) +#define CSC_D_MISC_CFG_0_CONV_MODE_DIRECT (_MK_ENUM_CONST(0)) +#define CSC_D_MISC_CFG_0_CONV_MODE_WINOGRAD (_MK_ENUM_CONST(1)) + +#define CSC_D_MISC_CFG_0_IN_PRECISION_SHIFT (_MK_SHIFT_CONST(8)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, CSC_D_MISC_CFG_0_IN_PRECISION_SHIFT)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_RANGE (9:8) +#define CSC_D_MISC_CFG_0_IN_PRECISION_WOFFSET (0x0) +#define CSC_D_MISC_CFG_0_IN_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_INIT_ENUM (INT16) +#define CSC_D_MISC_CFG_0_IN_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define CSC_D_MISC_CFG_0_IN_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define CSC_D_MISC_CFG_0_PROC_PRECISION_SHIFT (_MK_SHIFT_CONST(12)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, CSC_D_MISC_CFG_0_PROC_PRECISION_SHIFT)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_RANGE (13:12) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_WOFFSET (0x0) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_INIT_ENUM (INT16) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define CSC_D_MISC_CFG_0_DATA_REUSE_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_DATA_REUSE_SHIFT)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_RANGE (16:16) +#define CSC_D_MISC_CFG_0_DATA_REUSE_WOFFSET (0x0) +#define CSC_D_MISC_CFG_0_DATA_REUSE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_INIT_ENUM (DISABLE) +#define CSC_D_MISC_CFG_0_DATA_REUSE_DISABLE (_MK_ENUM_CONST(0)) +#define CSC_D_MISC_CFG_0_DATA_REUSE_ENABLE (_MK_ENUM_CONST(1)) + +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT (_MK_SHIFT_CONST(20)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_RANGE (20:20) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_WOFFSET (0x0) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_INIT_ENUM (DISABLE) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_DISABLE (_MK_ENUM_CONST(0)) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_ENABLE (_MK_ENUM_CONST(1)) + +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT (_MK_SHIFT_CONST(24)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_RANGE (24:24) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_WOFFSET (0x0) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_INIT_ENUM (DISABLE) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_DISABLE (_MK_ENUM_CONST(0)) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_ENABLE (_MK_ENUM_CONST(1)) + +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT (_MK_SHIFT_CONST(28)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_RANGE (28:28) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_WOFFSET (0x0) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_INIT_ENUM (DISABLE) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DISABLE (_MK_ENUM_CONST(0)) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CSC_D_DATAIN_FORMAT_0 +#define CSC_D_DATAIN_FORMAT_0 (_MK_ADDR_CONST(0x6010)) +#define CSC_D_DATAIN_FORMAT_0_SECURE (0x0) +#define CSC_D_DATAIN_FORMAT_0_DUAL (0x0) +#define CSC_D_DATAIN_FORMAT_0_SCR (0) +#define CSC_D_DATAIN_FORMAT_0_WORD_COUNT (0x1) +#define CSC_D_DATAIN_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_DATAIN_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_DATAIN_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_RANGE (0:0) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_WOFFSET (0x0) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_INIT_ENUM (FEATURE) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FEATURE (_MK_ENUM_CONST(0)) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PIXEL (_MK_ENUM_CONST(1)) + + +// Register CSC_D_DATAIN_SIZE_EXT_0_0 +#define CSC_D_DATAIN_SIZE_EXT_0_0 (_MK_ADDR_CONST(0x6014)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_SECURE (0x0) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DUAL (0x0) +#define CSC_D_DATAIN_SIZE_EXT_0_0_SCR (0) +#define CSC_D_DATAIN_SIZE_EXT_0_0_WORD_COUNT (0x1) +#define CSC_D_DATAIN_SIZE_EXT_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_RESET_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_READ_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_WRITE_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_RANGE (12:0) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_WOFFSET (0x0) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_RANGE (28:16) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_WOFFSET (0x0) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_DATAIN_SIZE_EXT_1_0 +#define CSC_D_DATAIN_SIZE_EXT_1_0 (_MK_ADDR_CONST(0x6018)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_SECURE (0x0) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DUAL (0x0) +#define CSC_D_DATAIN_SIZE_EXT_1_0_SCR (0) +#define CSC_D_DATAIN_SIZE_EXT_1_0_WORD_COUNT (0x1) +#define CSC_D_DATAIN_SIZE_EXT_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_SHIFT)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_RANGE (12:0) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_WOFFSET (0x0) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_BATCH_NUMBER_0 +#define CSC_D_BATCH_NUMBER_0 (_MK_ADDR_CONST(0x601c)) +#define CSC_D_BATCH_NUMBER_0_SECURE (0x0) +#define CSC_D_BATCH_NUMBER_0_DUAL (0x0) +#define CSC_D_BATCH_NUMBER_0_SCR (0) +#define CSC_D_BATCH_NUMBER_0_WORD_COUNT (0x1) +#define CSC_D_BATCH_NUMBER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_BATCH_NUMBER_0_RESET_MASK (_MK_MASK_CONST(0x1f)) +#define CSC_D_BATCH_NUMBER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_BATCH_NUMBER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_BATCH_NUMBER_0_READ_MASK (_MK_MASK_CONST(0x1f)) +#define CSC_D_BATCH_NUMBER_0_WRITE_MASK (_MK_MASK_CONST(0x1f)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_FIELD \ + (_MK_FIELD_CONST(0x1f, CSC_D_BATCH_NUMBER_0_BATCHES_SHIFT)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_RANGE (4:0) +#define CSC_D_BATCH_NUMBER_0_BATCHES_WOFFSET (0x0) +#define CSC_D_BATCH_NUMBER_0_BATCHES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_BATCH_NUMBER_0_BATCHES_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_POST_Y_EXTENSION_0 +#define CSC_D_POST_Y_EXTENSION_0 (_MK_ADDR_CONST(0x6020)) +#define CSC_D_POST_Y_EXTENSION_0_SECURE (0x0) +#define CSC_D_POST_Y_EXTENSION_0_DUAL (0x0) +#define CSC_D_POST_Y_EXTENSION_0_SCR (0) +#define CSC_D_POST_Y_EXTENSION_0_WORD_COUNT (0x1) +#define CSC_D_POST_Y_EXTENSION_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_POST_Y_EXTENSION_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_POST_Y_EXTENSION_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_POST_Y_EXTENSION_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_POST_Y_EXTENSION_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_POST_Y_EXTENSION_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_FIELD \ + (_MK_FIELD_CONST(0x3, CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_SHIFT)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_RANGE (1:0) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_WOFFSET (0x0) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_ENTRY_PER_SLICE_0 +#define CSC_D_ENTRY_PER_SLICE_0 (_MK_ADDR_CONST(0x6024)) +#define CSC_D_ENTRY_PER_SLICE_0_SECURE (0x0) +#define CSC_D_ENTRY_PER_SLICE_0_DUAL (0x0) +#define CSC_D_ENTRY_PER_SLICE_0_SCR (0) +#define CSC_D_ENTRY_PER_SLICE_0_WORD_COUNT (0x1) +#define CSC_D_ENTRY_PER_SLICE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_ENTRY_PER_SLICE_0_RESET_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_ENTRY_PER_SLICE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_ENTRY_PER_SLICE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ENTRY_PER_SLICE_0_READ_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_ENTRY_PER_SLICE_0_WRITE_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_FIELD \ + (_MK_FIELD_CONST(0xfff, CSC_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_RANGE (11:0) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_WOFFSET (0x0) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_DEFAULT_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_WEIGHT_FORMAT_0 +#define CSC_D_WEIGHT_FORMAT_0 (_MK_ADDR_CONST(0x6028)) +#define CSC_D_WEIGHT_FORMAT_0_SECURE (0x0) +#define CSC_D_WEIGHT_FORMAT_0_DUAL (0x0) +#define CSC_D_WEIGHT_FORMAT_0_SCR (0) +#define CSC_D_WEIGHT_FORMAT_0_WORD_COUNT (0x1) +#define CSC_D_WEIGHT_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_WEIGHT_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_WEIGHT_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_FIELD \ + (_MK_FIELD_CONST(0x1, CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_RANGE (0:0) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_WOFFSET (0x0) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_INIT_ENUM (UNCOMPRESSED) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_UNCOMPRESSED (_MK_ENUM_CONST(0)) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_COMPRESSED (_MK_ENUM_CONST(1)) + + +// Register CSC_D_WEIGHT_SIZE_EXT_0_0 +#define CSC_D_WEIGHT_SIZE_EXT_0_0 (_MK_ADDR_CONST(0x602c)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_SECURE (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_DUAL (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_SCR (0) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WORD_COUNT (0x1) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_RESET_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_READ_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WRITE_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_SHIFT)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_RANGE (4:0) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_WOFFSET (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_SHIFT)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_RANGE (20:16) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_WOFFSET (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_WEIGHT_SIZE_EXT_1_0 +#define CSC_D_WEIGHT_SIZE_EXT_1_0 (_MK_ADDR_CONST(0x6030)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_SECURE (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_DUAL (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_SCR (0) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WORD_COUNT (0x1) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_READ_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_SHIFT)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_RANGE (12:0) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_WOFFSET (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_SHIFT)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_RANGE (28:16) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_WOFFSET (0x0) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_WEIGHT_BYTES_0 +#define CSC_D_WEIGHT_BYTES_0 (_MK_ADDR_CONST(0x6034)) +#define CSC_D_WEIGHT_BYTES_0_SECURE (0x0) +#define CSC_D_WEIGHT_BYTES_0_DUAL (0x0) +#define CSC_D_WEIGHT_BYTES_0_SCR (0) +#define CSC_D_WEIGHT_BYTES_0_WORD_COUNT (0x1) +#define CSC_D_WEIGHT_BYTES_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_BYTES_0_RESET_MASK (_MK_MASK_CONST(0xffffff80)) +#define CSC_D_WEIGHT_BYTES_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_BYTES_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_BYTES_0_READ_MASK (_MK_MASK_CONST(0xffffff80)) +#define CSC_D_WEIGHT_BYTES_0_WRITE_MASK (_MK_MASK_CONST(0xffffff80)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT (_MK_SHIFT_CONST(7)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_FIELD \ + (_MK_FIELD_CONST(0x1ffffff, CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_RANGE (31:7) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_WOFFSET (0x0) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1ffffff)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_WMB_BYTES_0 +#define CSC_D_WMB_BYTES_0 (_MK_ADDR_CONST(0x6038)) +#define CSC_D_WMB_BYTES_0_SECURE (0x0) +#define CSC_D_WMB_BYTES_0_DUAL (0x0) +#define CSC_D_WMB_BYTES_0_SCR (0) +#define CSC_D_WMB_BYTES_0_WORD_COUNT (0x1) +#define CSC_D_WMB_BYTES_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WMB_BYTES_0_RESET_MASK (_MK_MASK_CONST(0xfffff80)) +#define CSC_D_WMB_BYTES_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_WMB_BYTES_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_WMB_BYTES_0_READ_MASK (_MK_MASK_CONST(0xfffff80)) +#define CSC_D_WMB_BYTES_0_WRITE_MASK (_MK_MASK_CONST(0xfffff80)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_SHIFT (_MK_SHIFT_CONST(7)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_FIELD \ + (_MK_FIELD_CONST(0x1fffff, CSC_D_WMB_BYTES_0_WMB_BYTES_SHIFT)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_RANGE (27:7) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_WOFFSET (0x0) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_DEFAULT_MASK (_MK_MASK_CONST(0x1fffff)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_DATAOUT_SIZE_0_0 +#define CSC_D_DATAOUT_SIZE_0_0 (_MK_ADDR_CONST(0x603c)) +#define CSC_D_DATAOUT_SIZE_0_0_SECURE (0x0) +#define CSC_D_DATAOUT_SIZE_0_0_DUAL (0x0) +#define CSC_D_DATAOUT_SIZE_0_0_SCR (0) +#define CSC_D_DATAOUT_SIZE_0_0_WORD_COUNT (0x1) +#define CSC_D_DATAOUT_SIZE_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_RESET_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_DATAOUT_SIZE_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_READ_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_DATAOUT_SIZE_0_0_WRITE_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_RANGE (12:0) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_WOFFSET (0x0) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_RANGE (28:16) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_WOFFSET (0x0) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_DATAOUT_SIZE_1_0 +#define CSC_D_DATAOUT_SIZE_1_0 (_MK_ADDR_CONST(0x6040)) +#define CSC_D_DATAOUT_SIZE_1_0_SECURE (0x0) +#define CSC_D_DATAOUT_SIZE_1_0_DUAL (0x0) +#define CSC_D_DATAOUT_SIZE_1_0_SCR (0) +#define CSC_D_DATAOUT_SIZE_1_0_WORD_COUNT (0x1) +#define CSC_D_DATAOUT_SIZE_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAOUT_SIZE_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_1_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAOUT_SIZE_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_RANGE (12:0) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_WOFFSET (0x0) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_ATOMICS_0 +#define CSC_D_ATOMICS_0 (_MK_ADDR_CONST(0x6044)) +#define CSC_D_ATOMICS_0_SECURE (0x0) +#define CSC_D_ATOMICS_0_DUAL (0x0) +#define CSC_D_ATOMICS_0_SCR (0) +#define CSC_D_ATOMICS_0_WORD_COUNT (0x1) +#define CSC_D_ATOMICS_0_RESET_VAL (_MK_MASK_CONST(0x1)) +#define CSC_D_ATOMICS_0_RESET_MASK (_MK_MASK_CONST(0x1fffff)) +#define CSC_D_ATOMICS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_ATOMICS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ATOMICS_0_READ_MASK (_MK_MASK_CONST(0x1fffff)) +#define CSC_D_ATOMICS_0_WRITE_MASK (_MK_MASK_CONST(0x1fffff)) +#define CSC_D_ATOMICS_0_ATOMICS_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_ATOMICS_0_ATOMICS_FIELD \ + (_MK_FIELD_CONST(0x1fffff, CSC_D_ATOMICS_0_ATOMICS_SHIFT)) +#define CSC_D_ATOMICS_0_ATOMICS_RANGE (20:0) +#define CSC_D_ATOMICS_0_ATOMICS_WOFFSET (0x0) +#define CSC_D_ATOMICS_0_ATOMICS_DEFAULT (_MK_MASK_CONST(0x1)) +#define CSC_D_ATOMICS_0_ATOMICS_DEFAULT_MASK (_MK_MASK_CONST(0x1fffff)) +#define CSC_D_ATOMICS_0_ATOMICS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ATOMICS_0_ATOMICS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ATOMICS_0_ATOMICS_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_ATOMICS_0_ATOMICS_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_RELEASE_0 +#define CSC_D_RELEASE_0 (_MK_ADDR_CONST(0x6048)) +#define CSC_D_RELEASE_0_SECURE (0x0) +#define CSC_D_RELEASE_0_DUAL (0x0) +#define CSC_D_RELEASE_0_SCR (0) +#define CSC_D_RELEASE_0_WORD_COUNT (0x1) +#define CSC_D_RELEASE_0_RESET_VAL (_MK_MASK_CONST(0x1)) +#define CSC_D_RELEASE_0_RESET_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_RELEASE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_RELEASE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_RELEASE_0_READ_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_RELEASE_0_WRITE_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_RELEASE_0_RLS_SLICES_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_RELEASE_0_RLS_SLICES_FIELD \ + (_MK_FIELD_CONST(0xfff, CSC_D_RELEASE_0_RLS_SLICES_SHIFT)) +#define CSC_D_RELEASE_0_RLS_SLICES_RANGE (11:0) +#define CSC_D_RELEASE_0_RLS_SLICES_WOFFSET (0x0) +#define CSC_D_RELEASE_0_RLS_SLICES_DEFAULT (_MK_MASK_CONST(0x1)) +#define CSC_D_RELEASE_0_RLS_SLICES_DEFAULT_MASK (_MK_MASK_CONST(0xfff)) +#define CSC_D_RELEASE_0_RLS_SLICES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_RELEASE_0_RLS_SLICES_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_RELEASE_0_RLS_SLICES_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_RELEASE_0_RLS_SLICES_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_CONV_STRIDE_EXT_0 +#define CSC_D_CONV_STRIDE_EXT_0 (_MK_ADDR_CONST(0x604c)) +#define CSC_D_CONV_STRIDE_EXT_0_SECURE (0x0) +#define CSC_D_CONV_STRIDE_EXT_0_DUAL (0x0) +#define CSC_D_CONV_STRIDE_EXT_0_SCR (0) +#define CSC_D_CONV_STRIDE_EXT_0_WORD_COUNT (0x1) +#define CSC_D_CONV_STRIDE_EXT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_RESET_MASK (_MK_MASK_CONST(0x70007)) +#define CSC_D_CONV_STRIDE_EXT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_READ_MASK (_MK_MASK_CONST(0x70007)) +#define CSC_D_CONV_STRIDE_EXT_0_WRITE_MASK (_MK_MASK_CONST(0x70007)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_FIELD \ + (_MK_FIELD_CONST(0x7, \ + CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_SHIFT)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_RANGE (2:0) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_WOFFSET (0x0) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_FIELD \ + (_MK_FIELD_CONST(0x7, \ + CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_SHIFT)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_RANGE (18:16) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_WOFFSET (0x0) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_DILATION_EXT_0 +#define CSC_D_DILATION_EXT_0 (_MK_ADDR_CONST(0x6050)) +#define CSC_D_DILATION_EXT_0_SECURE (0x0) +#define CSC_D_DILATION_EXT_0_DUAL (0x0) +#define CSC_D_DILATION_EXT_0_SCR (0) +#define CSC_D_DILATION_EXT_0_WORD_COUNT (0x1) +#define CSC_D_DILATION_EXT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_RESET_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_DILATION_EXT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_READ_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_DILATION_EXT_0_WRITE_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_FIELD \ + (_MK_FIELD_CONST(0x1f, CSC_D_DILATION_EXT_0_X_DILATION_EXT_SHIFT)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_RANGE (4:0) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_WOFFSET (0x0) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_FIELD \ + (_MK_FIELD_CONST(0x1f, CSC_D_DILATION_EXT_0_Y_DILATION_EXT_SHIFT)) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_RANGE (20:16) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_WOFFSET (0x0) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_ZERO_PADDING_0 +#define CSC_D_ZERO_PADDING_0 (_MK_ADDR_CONST(0x6054)) +#define CSC_D_ZERO_PADDING_0_SECURE (0x0) +#define CSC_D_ZERO_PADDING_0_DUAL (0x0) +#define CSC_D_ZERO_PADDING_0_SCR (0) +#define CSC_D_ZERO_PADDING_0_WORD_COUNT (0x1) +#define CSC_D_ZERO_PADDING_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_RESET_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_ZERO_PADDING_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_READ_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_ZERO_PADDING_0_WRITE_MASK (_MK_MASK_CONST(0x1f001f)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_FIELD \ + (_MK_FIELD_CONST(0x1f, CSC_D_ZERO_PADDING_0_PAD_LEFT_SHIFT)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_RANGE (4:0) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_WOFFSET (0x0) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CSC_D_ZERO_PADDING_0_PAD_TOP_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_FIELD \ + (_MK_FIELD_CONST(0x1f, CSC_D_ZERO_PADDING_0_PAD_TOP_SHIFT)) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_RANGE (20:16) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_WOFFSET (0x0) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_ZERO_PADDING_VALUE_0 +#define CSC_D_ZERO_PADDING_VALUE_0 (_MK_ADDR_CONST(0x6058)) +#define CSC_D_ZERO_PADDING_VALUE_0_SECURE (0x0) +#define CSC_D_ZERO_PADDING_VALUE_0_DUAL (0x0) +#define CSC_D_ZERO_PADDING_VALUE_0_SCR (0) +#define CSC_D_ZERO_PADDING_VALUE_0_WORD_COUNT (0x1) +#define CSC_D_ZERO_PADDING_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CSC_D_ZERO_PADDING_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CSC_D_ZERO_PADDING_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_FIELD \ + (_MK_FIELD_CONST(0xffff, CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_RANGE (15:0) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_WOFFSET (0x0) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_BANK_0 +#define CSC_D_BANK_0 (_MK_ADDR_CONST(0x605c)) +#define CSC_D_BANK_0_SECURE (0x0) +#define CSC_D_BANK_0_DUAL (0x0) +#define CSC_D_BANK_0_SCR (0) +#define CSC_D_BANK_0_WORD_COUNT (0x1) +#define CSC_D_BANK_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_RESET_MASK (_MK_MASK_CONST(0xf000f)) +#define CSC_D_BANK_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_READ_MASK (_MK_MASK_CONST(0xf000f)) +#define CSC_D_BANK_0_WRITE_MASK (_MK_MASK_CONST(0xf000f)) +#define CSC_D_BANK_0_DATA_BANK_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_BANK_0_DATA_BANK_FIELD \ + (_MK_FIELD_CONST(0xf, CSC_D_BANK_0_DATA_BANK_SHIFT)) +#define CSC_D_BANK_0_DATA_BANK_RANGE (3:0) +#define CSC_D_BANK_0_DATA_BANK_WOFFSET (0x0) +#define CSC_D_BANK_0_DATA_BANK_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_DATA_BANK_DEFAULT_MASK (_MK_MASK_CONST(0xf)) +#define CSC_D_BANK_0_DATA_BANK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_DATA_BANK_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_DATA_BANK_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_DATA_BANK_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + +#define CSC_D_BANK_0_WEIGHT_BANK_SHIFT (_MK_SHIFT_CONST(16)) +#define CSC_D_BANK_0_WEIGHT_BANK_FIELD \ + (_MK_FIELD_CONST(0xf, CSC_D_BANK_0_WEIGHT_BANK_SHIFT)) +#define CSC_D_BANK_0_WEIGHT_BANK_RANGE (19:16) +#define CSC_D_BANK_0_WEIGHT_BANK_WOFFSET (0x0) +#define CSC_D_BANK_0_WEIGHT_BANK_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_WEIGHT_BANK_DEFAULT_MASK (_MK_MASK_CONST(0xf)) +#define CSC_D_BANK_0_WEIGHT_BANK_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_WEIGHT_BANK_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_WEIGHT_BANK_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_BANK_0_WEIGHT_BANK_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_PRA_CFG_0 +#define CSC_D_PRA_CFG_0 (_MK_ADDR_CONST(0x6060)) +#define CSC_D_PRA_CFG_0_SECURE (0x0) +#define CSC_D_PRA_CFG_0_DUAL (0x0) +#define CSC_D_PRA_CFG_0_SCR (0) +#define CSC_D_PRA_CFG_0_WORD_COUNT (0x1) +#define CSC_D_PRA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_PRA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_PRA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_PRA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_PRA_CFG_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_PRA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_FIELD \ + (_MK_FIELD_CONST(0x3, CSC_D_PRA_CFG_0_PRA_TRUNCATE_SHIFT)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_RANGE (1:0) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_WOFFSET (0x0) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CSC_D_CYA_0 +#define CSC_D_CYA_0 (_MK_ADDR_CONST(0x6064)) +#define CSC_D_CYA_0_SECURE (0x0) +#define CSC_D_CYA_0_DUAL (0x0) +#define CSC_D_CYA_0_SCR (0) +#define CSC_D_CYA_0_WORD_COUNT (0x1) +#define CSC_D_CYA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_CYA_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CSC_D_CYA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CSC_D_CYA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_CYA_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CSC_D_CYA_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CSC_D_CYA_0_CYA_SHIFT (_MK_SHIFT_CONST(0)) +#define CSC_D_CYA_0_CYA_FIELD \ + (_MK_FIELD_CONST(0xffffffff, CSC_D_CYA_0_CYA_SHIFT)) +#define CSC_D_CYA_0_CYA_RANGE (31:0) +#define CSC_D_CYA_0_CYA_WOFFSET (0x0) +#define CSC_D_CYA_0_CYA_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_CYA_0_CYA_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define CSC_D_CYA_0_CYA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CSC_D_CYA_0_CYA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CSC_D_CYA_0_CYA_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CSC_D_CYA_0_CYA_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CMAC_A_S_STATUS_0 +#define CMAC_A_S_STATUS_0 (_MK_ADDR_CONST(0x7000)) +#define CMAC_A_S_STATUS_0_SECURE (0x0) +#define CMAC_A_S_STATUS_0_DUAL (0x0) +#define CMAC_A_S_STATUS_0_SCR (0) +#define CMAC_A_S_STATUS_0_WORD_COUNT (0x1) +#define CMAC_A_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define CMAC_A_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define CMAC_A_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_A_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, CMAC_A_S_STATUS_0_STATUS_0_SHIFT)) +#define CMAC_A_S_STATUS_0_STATUS_0_RANGE (1:0) +#define CMAC_A_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define CMAC_A_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CMAC_A_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_A_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define CMAC_A_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define CMAC_A_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define CMAC_A_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define CMAC_A_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CMAC_A_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, CMAC_A_S_STATUS_0_STATUS_1_SHIFT)) +#define CMAC_A_S_STATUS_0_STATUS_1_RANGE (17:16) +#define CMAC_A_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define CMAC_A_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CMAC_A_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_A_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define CMAC_A_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define CMAC_A_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define CMAC_A_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register CMAC_A_S_POINTER_0 +#define CMAC_A_S_POINTER_0 (_MK_ADDR_CONST(0x7004)) +#define CMAC_A_S_POINTER_0_SECURE (0x0) +#define CMAC_A_S_POINTER_0_DUAL (0x0) +#define CMAC_A_S_POINTER_0_SCR (0) +#define CMAC_A_S_POINTER_0_WORD_COUNT (0x1) +#define CMAC_A_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CMAC_A_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CMAC_A_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_A_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_A_S_POINTER_0_PRODUCER_SHIFT)) +#define CMAC_A_S_POINTER_0_PRODUCER_RANGE (0:0) +#define CMAC_A_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define CMAC_A_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_A_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define CMAC_A_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CMAC_A_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define CMAC_A_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define CMAC_A_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_A_S_POINTER_0_CONSUMER_SHIFT)) +#define CMAC_A_S_POINTER_0_CONSUMER_RANGE (16:16) +#define CMAC_A_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define CMAC_A_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_A_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_A_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define CMAC_A_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CMAC_A_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register CMAC_A_D_OP_ENABLE_0 +#define CMAC_A_D_OP_ENABLE_0 (_MK_ADDR_CONST(0x7008)) +#define CMAC_A_D_OP_ENABLE_0_SECURE (0x0) +#define CMAC_A_D_OP_ENABLE_0_DUAL (0x0) +#define CMAC_A_D_OP_ENABLE_0_SCR (0) +#define CMAC_A_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define CMAC_A_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_A_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CMAC_A_D_MISC_CFG_0 +#define CMAC_A_D_MISC_CFG_0 (_MK_ADDR_CONST(0x700c)) +#define CMAC_A_D_MISC_CFG_0_SECURE (0x0) +#define CMAC_A_D_MISC_CFG_0_DUAL (0x0) +#define CMAC_A_D_MISC_CFG_0_SCR (0) +#define CMAC_A_D_MISC_CFG_0_WORD_COUNT (0x1) +#define CMAC_A_D_MISC_CFG_0_RESET_VAL (_MK_MASK_CONST(0x1000)) +#define CMAC_A_D_MISC_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3001)) +#define CMAC_A_D_MISC_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_READ_MASK (_MK_MASK_CONST(0x3001)) +#define CMAC_A_D_MISC_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3001)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_A_D_MISC_CFG_0_CONV_MODE_SHIFT)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_RANGE (0:0) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_WOFFSET (0x0) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_INIT_ENUM (DIRECT) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_DIRECT (_MK_ENUM_CONST(0)) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_WINOGRAD (_MK_ENUM_CONST(1)) + +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_SHIFT (_MK_SHIFT_CONST(12)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, CMAC_A_D_MISC_CFG_0_PROC_PRECISION_SHIFT)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_RANGE (13:12) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_WOFFSET (0x0) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_INIT_ENUM (INT16) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_FP16 (_MK_ENUM_CONST(2)) + + +// Register CMAC_B_S_STATUS_0 +#define CMAC_B_S_STATUS_0 (_MK_ADDR_CONST(0x8000)) +#define CMAC_B_S_STATUS_0_SECURE (0x0) +#define CMAC_B_S_STATUS_0_DUAL (0x0) +#define CMAC_B_S_STATUS_0_SCR (0) +#define CMAC_B_S_STATUS_0_WORD_COUNT (0x1) +#define CMAC_B_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define CMAC_B_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define CMAC_B_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_B_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, CMAC_B_S_STATUS_0_STATUS_0_SHIFT)) +#define CMAC_B_S_STATUS_0_STATUS_0_RANGE (1:0) +#define CMAC_B_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define CMAC_B_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CMAC_B_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_B_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define CMAC_B_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define CMAC_B_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define CMAC_B_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define CMAC_B_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CMAC_B_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, CMAC_B_S_STATUS_0_STATUS_1_SHIFT)) +#define CMAC_B_S_STATUS_0_STATUS_1_RANGE (17:16) +#define CMAC_B_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define CMAC_B_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CMAC_B_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_B_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define CMAC_B_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define CMAC_B_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define CMAC_B_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register CMAC_B_S_POINTER_0 +#define CMAC_B_S_POINTER_0 (_MK_ADDR_CONST(0x8004)) +#define CMAC_B_S_POINTER_0_SECURE (0x0) +#define CMAC_B_S_POINTER_0_DUAL (0x0) +#define CMAC_B_S_POINTER_0_SCR (0) +#define CMAC_B_S_POINTER_0_WORD_COUNT (0x1) +#define CMAC_B_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CMAC_B_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CMAC_B_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_B_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_B_S_POINTER_0_PRODUCER_SHIFT)) +#define CMAC_B_S_POINTER_0_PRODUCER_RANGE (0:0) +#define CMAC_B_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define CMAC_B_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_B_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define CMAC_B_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CMAC_B_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define CMAC_B_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define CMAC_B_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_B_S_POINTER_0_CONSUMER_SHIFT)) +#define CMAC_B_S_POINTER_0_CONSUMER_RANGE (16:16) +#define CMAC_B_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define CMAC_B_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_B_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_B_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define CMAC_B_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CMAC_B_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register CMAC_B_D_OP_ENABLE_0 +#define CMAC_B_D_OP_ENABLE_0 (_MK_ADDR_CONST(0x8008)) +#define CMAC_B_D_OP_ENABLE_0_SECURE (0x0) +#define CMAC_B_D_OP_ENABLE_0_DUAL (0x0) +#define CMAC_B_D_OP_ENABLE_0_SCR (0) +#define CMAC_B_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define CMAC_B_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_B_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CMAC_B_D_MISC_CFG_0 +#define CMAC_B_D_MISC_CFG_0 (_MK_ADDR_CONST(0x800c)) +#define CMAC_B_D_MISC_CFG_0_SECURE (0x0) +#define CMAC_B_D_MISC_CFG_0_DUAL (0x0) +#define CMAC_B_D_MISC_CFG_0_SCR (0) +#define CMAC_B_D_MISC_CFG_0_WORD_COUNT (0x1) +#define CMAC_B_D_MISC_CFG_0_RESET_VAL (_MK_MASK_CONST(0x1000)) +#define CMAC_B_D_MISC_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3001)) +#define CMAC_B_D_MISC_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_READ_MASK (_MK_MASK_CONST(0x3001)) +#define CMAC_B_D_MISC_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3001)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, CMAC_B_D_MISC_CFG_0_CONV_MODE_SHIFT)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_RANGE (0:0) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_WOFFSET (0x0) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_INIT_ENUM (DIRECT) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_DIRECT (_MK_ENUM_CONST(0)) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_WINOGRAD (_MK_ENUM_CONST(1)) + +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_SHIFT (_MK_SHIFT_CONST(12)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, CMAC_B_D_MISC_CFG_0_PROC_PRECISION_SHIFT)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_RANGE (13:12) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_WOFFSET (0x0) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_INIT_ENUM (INT16) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_FP16 (_MK_ENUM_CONST(2)) + + +// Register CACC_S_STATUS_0 +#define CACC_S_STATUS_0 (_MK_ADDR_CONST(0x9000)) +#define CACC_S_STATUS_0_SECURE (0x0) +#define CACC_S_STATUS_0_DUAL (0x0) +#define CACC_S_STATUS_0_SCR (0) +#define CACC_S_STATUS_0_WORD_COUNT (0x1) +#define CACC_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define CACC_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define CACC_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, CACC_S_STATUS_0_STATUS_0_SHIFT)) +#define CACC_S_STATUS_0_STATUS_0_RANGE (1:0) +#define CACC_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define CACC_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CACC_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CACC_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define CACC_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define CACC_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define CACC_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define CACC_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CACC_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, CACC_S_STATUS_0_STATUS_1_SHIFT)) +#define CACC_S_STATUS_0_STATUS_1_RANGE (17:16) +#define CACC_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define CACC_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CACC_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CACC_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define CACC_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define CACC_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define CACC_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register CACC_S_POINTER_0 +#define CACC_S_POINTER_0 (_MK_ADDR_CONST(0x9004)) +#define CACC_S_POINTER_0_SECURE (0x0) +#define CACC_S_POINTER_0_DUAL (0x0) +#define CACC_S_POINTER_0_SCR (0) +#define CACC_S_POINTER_0_WORD_COUNT (0x1) +#define CACC_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CACC_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CACC_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CACC_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, CACC_S_POINTER_0_PRODUCER_SHIFT)) +#define CACC_S_POINTER_0_PRODUCER_RANGE (0:0) +#define CACC_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define CACC_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CACC_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CACC_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define CACC_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CACC_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define CACC_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define CACC_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, CACC_S_POINTER_0_CONSUMER_SHIFT)) +#define CACC_S_POINTER_0_CONSUMER_RANGE (16:16) +#define CACC_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define CACC_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CACC_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CACC_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define CACC_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CACC_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register CACC_D_OP_ENABLE_0 +#define CACC_D_OP_ENABLE_0 (_MK_ADDR_CONST(0x9008)) +#define CACC_D_OP_ENABLE_0_SECURE (0x0) +#define CACC_D_OP_ENABLE_0_DUAL (0x0) +#define CACC_D_OP_ENABLE_0_SCR (0) +#define CACC_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define CACC_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CACC_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CACC_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CACC_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CACC_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define CACC_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define CACC_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define CACC_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CACC_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CACC_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define CACC_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CACC_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CACC_D_MISC_CFG_0 +#define CACC_D_MISC_CFG_0 (_MK_ADDR_CONST(0x900c)) +#define CACC_D_MISC_CFG_0_SECURE (0x0) +#define CACC_D_MISC_CFG_0_DUAL (0x0) +#define CACC_D_MISC_CFG_0_SCR (0) +#define CACC_D_MISC_CFG_0_WORD_COUNT (0x1) +#define CACC_D_MISC_CFG_0_RESET_VAL (_MK_MASK_CONST(0x1000)) +#define CACC_D_MISC_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3001)) +#define CACC_D_MISC_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_READ_MASK (_MK_MASK_CONST(0x3001)) +#define CACC_D_MISC_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3001)) +#define CACC_D_MISC_CFG_0_CONV_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_MISC_CFG_0_CONV_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, CACC_D_MISC_CFG_0_CONV_MODE_SHIFT)) +#define CACC_D_MISC_CFG_0_CONV_MODE_RANGE (0:0) +#define CACC_D_MISC_CFG_0_CONV_MODE_WOFFSET (0x0) +#define CACC_D_MISC_CFG_0_CONV_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_CONV_MODE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CACC_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_CONV_MODE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_CONV_MODE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_CONV_MODE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CACC_D_MISC_CFG_0_CONV_MODE_INIT_ENUM (DIRECT) +#define CACC_D_MISC_CFG_0_CONV_MODE_DIRECT (_MK_ENUM_CONST(0)) +#define CACC_D_MISC_CFG_0_CONV_MODE_WINOGRAD (_MK_ENUM_CONST(1)) + +#define CACC_D_MISC_CFG_0_PROC_PRECISION_SHIFT (_MK_SHIFT_CONST(12)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, CACC_D_MISC_CFG_0_PROC_PRECISION_SHIFT)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_RANGE (13:12) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_WOFFSET (0x0) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_INIT_ENUM (INT16) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_FP16 (_MK_ENUM_CONST(2)) + + +// Register CACC_D_DATAOUT_SIZE_0_0 +#define CACC_D_DATAOUT_SIZE_0_0 (_MK_ADDR_CONST(0x9010)) +#define CACC_D_DATAOUT_SIZE_0_0_SECURE (0x0) +#define CACC_D_DATAOUT_SIZE_0_0_DUAL (0x0) +#define CACC_D_DATAOUT_SIZE_0_0_SCR (0) +#define CACC_D_DATAOUT_SIZE_0_0_WORD_COUNT (0x1) +#define CACC_D_DATAOUT_SIZE_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_RESET_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CACC_D_DATAOUT_SIZE_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_READ_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CACC_D_DATAOUT_SIZE_0_0_WRITE_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_RANGE (12:0) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_WOFFSET (0x0) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT (_MK_SHIFT_CONST(16)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_RANGE (28:16) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_WOFFSET (0x0) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_DATAOUT_SIZE_1_0 +#define CACC_D_DATAOUT_SIZE_1_0 (_MK_ADDR_CONST(0x9014)) +#define CACC_D_DATAOUT_SIZE_1_0_SECURE (0x0) +#define CACC_D_DATAOUT_SIZE_1_0_DUAL (0x0) +#define CACC_D_DATAOUT_SIZE_1_0_SCR (0) +#define CACC_D_DATAOUT_SIZE_1_0_WORD_COUNT (0x1) +#define CACC_D_DATAOUT_SIZE_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CACC_D_DATAOUT_SIZE_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_1_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CACC_D_DATAOUT_SIZE_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_RANGE (12:0) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_WOFFSET (0x0) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_DATAOUT_ADDR_0 +#define CACC_D_DATAOUT_ADDR_0 (_MK_ADDR_CONST(0x9018)) +#define CACC_D_DATAOUT_ADDR_0_SECURE (0x0) +#define CACC_D_DATAOUT_ADDR_0_DUAL (0x0) +#define CACC_D_DATAOUT_ADDR_0_SCR (0) +#define CACC_D_DATAOUT_ADDR_0_WORD_COUNT (0x1) +#define CACC_D_DATAOUT_ADDR_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_ADDR_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CACC_D_DATAOUT_ADDR_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_ADDR_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_ADDR_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CACC_D_DATAOUT_ADDR_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_SHIFT (_MK_SHIFT_CONST(5)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_SHIFT)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_RANGE (31:5) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_WOFFSET (0x0) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_BATCH_NUMBER_0 +#define CACC_D_BATCH_NUMBER_0 (_MK_ADDR_CONST(0x901c)) +#define CACC_D_BATCH_NUMBER_0_SECURE (0x0) +#define CACC_D_BATCH_NUMBER_0_DUAL (0x0) +#define CACC_D_BATCH_NUMBER_0_SCR (0) +#define CACC_D_BATCH_NUMBER_0_WORD_COUNT (0x1) +#define CACC_D_BATCH_NUMBER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_BATCH_NUMBER_0_RESET_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_BATCH_NUMBER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_BATCH_NUMBER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_BATCH_NUMBER_0_READ_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_BATCH_NUMBER_0_WRITE_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_FIELD \ + (_MK_FIELD_CONST(0x1f, CACC_D_BATCH_NUMBER_0_BATCHES_SHIFT)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_RANGE (4:0) +#define CACC_D_BATCH_NUMBER_0_BATCHES_WOFFSET (0x0) +#define CACC_D_BATCH_NUMBER_0_BATCHES_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_D_BATCH_NUMBER_0_BATCHES_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_LINE_STRIDE_0 +#define CACC_D_LINE_STRIDE_0 (_MK_ADDR_CONST(0x9020)) +#define CACC_D_LINE_STRIDE_0_SECURE (0x0) +#define CACC_D_LINE_STRIDE_0_DUAL (0x0) +#define CACC_D_LINE_STRIDE_0_SCR (0) +#define CACC_D_LINE_STRIDE_0_WORD_COUNT (0x1) +#define CACC_D_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffe0)) +#define CACC_D_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffe0)) +#define CACC_D_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffe0)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffff, CACC_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_RANGE (23:5) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_WOFFSET (0x0) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_SURF_STRIDE_0 +#define CACC_D_SURF_STRIDE_0 (_MK_ADDR_CONST(0x9024)) +#define CACC_D_SURF_STRIDE_0_SECURE (0x0) +#define CACC_D_SURF_STRIDE_0_DUAL (0x0) +#define CACC_D_SURF_STRIDE_0_SCR (0) +#define CACC_D_SURF_STRIDE_0_WORD_COUNT (0x1) +#define CACC_D_SURF_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_SURF_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffe0)) +#define CACC_D_SURF_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_SURF_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_SURF_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffe0)) +#define CACC_D_SURF_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffe0)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffff, CACC_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_RANGE (23:5) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_WOFFSET (0x0) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_DATAOUT_MAP_0 +#define CACC_D_DATAOUT_MAP_0 (_MK_ADDR_CONST(0x9028)) +#define CACC_D_DATAOUT_MAP_0_SECURE (0x0) +#define CACC_D_DATAOUT_MAP_0_DUAL (0x0) +#define CACC_D_DATAOUT_MAP_0_SCR (0) +#define CACC_D_DATAOUT_MAP_0_WORD_COUNT (0x1) +#define CACC_D_DATAOUT_MAP_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CACC_D_DATAOUT_MAP_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CACC_D_DATAOUT_MAP_0_WRITE_MASK (_MK_MASK_CONST(0x10001)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_FIELD \ + (_MK_FIELD_CONST(0x1, CACC_D_DATAOUT_MAP_0_LINE_PACKED_SHIFT)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_RANGE (0:0) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_WOFFSET (0x0) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_INIT_ENUM (FALSE) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_FALSE (_MK_ENUM_CONST(0)) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_TRUE (_MK_ENUM_CONST(1)) + +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_SHIFT (_MK_SHIFT_CONST(16)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_FIELD \ + (_MK_FIELD_CONST(0x1, CACC_D_DATAOUT_MAP_0_SURF_PACKED_SHIFT)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_RANGE (16:16) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_WOFFSET (0x0) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_INIT_ENUM (FALSE) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_FALSE (_MK_ENUM_CONST(0)) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_TRUE (_MK_ENUM_CONST(1)) + + +// Register CACC_D_CLIP_CFG_0 +#define CACC_D_CLIP_CFG_0 (_MK_ADDR_CONST(0x902c)) +#define CACC_D_CLIP_CFG_0_SECURE (0x0) +#define CACC_D_CLIP_CFG_0_DUAL (0x0) +#define CACC_D_CLIP_CFG_0_SCR (0) +#define CACC_D_CLIP_CFG_0_WORD_COUNT (0x1) +#define CACC_D_CLIP_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_CLIP_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_CLIP_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_CLIP_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_CLIP_CFG_0_READ_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_CLIP_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_FIELD \ + (_MK_FIELD_CONST(0x1f, CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_SHIFT)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_RANGE (4:0) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_WOFFSET (0x0) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_DEFAULT_MASK (_MK_MASK_CONST(0x1f)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_OUT_SATURATION_0 +#define CACC_D_OUT_SATURATION_0 (_MK_ADDR_CONST(0x9030)) +#define CACC_D_OUT_SATURATION_0_SECURE (0x0) +#define CACC_D_OUT_SATURATION_0_DUAL (0x0) +#define CACC_D_OUT_SATURATION_0_SCR (0) +#define CACC_D_OUT_SATURATION_0_WORD_COUNT (0x1) +#define CACC_D_OUT_SATURATION_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CACC_D_OUT_SATURATION_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CACC_D_OUT_SATURATION_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CACC_D_OUT_SATURATION_0_SAT_COUNT_SHIFT)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_RANGE (31:0) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_WOFFSET (0x0) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CACC_D_CYA_0 +#define CACC_D_CYA_0 (_MK_ADDR_CONST(0x9034)) +#define CACC_D_CYA_0_SECURE (0x0) +#define CACC_D_CYA_0_DUAL (0x0) +#define CACC_D_CYA_0_SCR (0) +#define CACC_D_CYA_0_WORD_COUNT (0x1) +#define CACC_D_CYA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_CYA_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CACC_D_CYA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CACC_D_CYA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_CYA_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CACC_D_CYA_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CACC_D_CYA_0_CYA_SHIFT (_MK_SHIFT_CONST(0)) +#define CACC_D_CYA_0_CYA_FIELD \ + (_MK_FIELD_CONST(0xffffffff, CACC_D_CYA_0_CYA_SHIFT)) +#define CACC_D_CYA_0_CYA_RANGE (31:0) +#define CACC_D_CYA_0_CYA_WOFFSET (0x0) +#define CACC_D_CYA_0_CYA_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_CYA_0_CYA_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define CACC_D_CYA_0_CYA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CACC_D_CYA_0_CYA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CACC_D_CYA_0_CYA_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CACC_D_CYA_0_CYA_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_S_STATUS_0 +#define SDP_RDMA_S_STATUS_0 (_MK_ADDR_CONST(0xa000)) +#define SDP_RDMA_S_STATUS_0_SECURE (0x0) +#define SDP_RDMA_S_STATUS_0_DUAL (0x0) +#define SDP_RDMA_S_STATUS_0_SCR (0) +#define SDP_RDMA_S_STATUS_0_WORD_COUNT (0x1) +#define SDP_RDMA_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define SDP_RDMA_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define SDP_RDMA_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_RDMA_S_STATUS_0_STATUS_0_SHIFT)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_RANGE (1:0) +#define SDP_RDMA_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define SDP_RDMA_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define SDP_RDMA_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define SDP_RDMA_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define SDP_RDMA_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_RDMA_S_STATUS_0_STATUS_1_SHIFT)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_RANGE (17:16) +#define SDP_RDMA_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define SDP_RDMA_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define SDP_RDMA_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define SDP_RDMA_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register SDP_RDMA_S_POINTER_0 +#define SDP_RDMA_S_POINTER_0 (_MK_ADDR_CONST(0xa004)) +#define SDP_RDMA_S_POINTER_0_SECURE (0x0) +#define SDP_RDMA_S_POINTER_0_DUAL (0x0) +#define SDP_RDMA_S_POINTER_0_SCR (0) +#define SDP_RDMA_S_POINTER_0_WORD_COUNT (0x1) +#define SDP_RDMA_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define SDP_RDMA_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define SDP_RDMA_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_S_POINTER_0_PRODUCER_SHIFT)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_RANGE (0:0) +#define SDP_RDMA_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define SDP_RDMA_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define SDP_RDMA_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define SDP_RDMA_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_S_POINTER_0_CONSUMER_SHIFT)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_RANGE (16:16) +#define SDP_RDMA_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define SDP_RDMA_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define SDP_RDMA_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define SDP_RDMA_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register SDP_RDMA_D_OP_ENABLE_0 +#define SDP_RDMA_D_OP_ENABLE_0 (_MK_ADDR_CONST(0xa008)) +#define SDP_RDMA_D_OP_ENABLE_0_SECURE (0x0) +#define SDP_RDMA_D_OP_ENABLE_0_DUAL (0x0) +#define SDP_RDMA_D_OP_ENABLE_0_SCR (0) +#define SDP_RDMA_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register SDP_RDMA_D_DATA_CUBE_WIDTH_0 +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0 (_MK_ADDR_CONST(0xa00c)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_SECURE (0x0) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_DUAL (0x0) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_SCR (0) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_RANGE (12:0) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_WOFFSET (0x0) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_DATA_CUBE_HEIGHT_0 +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0 (_MK_ADDR_CONST(0xa010)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_SECURE (0x0) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_DUAL (0x0) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_SCR (0) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_RANGE (12:0) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_WOFFSET (0x0) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_DATA_CUBE_CHANNEL_0 +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0 (_MK_ADDR_CONST(0xa014)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_SECURE (0x0) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_DUAL (0x0) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_SCR (0) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_RANGE (12:0) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_WOFFSET (0x0) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_SRC_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xa018)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SECURE (0x0) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_DUAL (0x0) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SCR (0) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_RANGE (31:5) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_WOFFSET (0x0) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xa01c)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SECURE (0x0) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_DUAL (0x0) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SCR (0) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_RANGE (31:0) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_WOFFSET (0x0) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_SRC_LINE_STRIDE_0 +#define SDP_RDMA_D_SRC_LINE_STRIDE_0 (_MK_ADDR_CONST(0xa020)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_SRC_SURFACE_STRIDE_0 +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xa024)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BRDMA_CFG_0 +#define SDP_RDMA_D_BRDMA_CFG_0 (_MK_ADDR_CONST(0xa028)) +#define SDP_RDMA_D_BRDMA_CFG_0_SECURE (0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_DUAL (0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_SCR (0) +#define SDP_RDMA_D_BRDMA_CFG_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BRDMA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_BRDMA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_BRDMA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_SHIFT)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_RANGE (0:0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_WOFFSET (0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_NO (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_YES (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_SHIFT)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_RANGE (2:1) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_WOFFSET (0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_MUL (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_ALU (_MK_ENUM_CONST(1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_BOTH (_MK_ENUM_CONST(2)) + +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_SHIFT (_MK_SHIFT_CONST(3)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_SHIFT)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_RANGE (3:3) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_WOFFSET (0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_ONE_BYTE (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_TWO_BYTE (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_SHIFT (_MK_SHIFT_CONST(4)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_SHIFT)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_RANGE (4:4) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_WOFFSET (0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_PER_KERNEL (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_PER_ELEMENT \ + (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_SHIFT)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_RANGE (5:5) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_WOFFSET (0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register SDP_RDMA_D_BS_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xa02c)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_SECURE (0x0) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_DUAL (0x0) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_SCR (0) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_SHIFT)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_RANGE (31:5) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_WOFFSET (0x0) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BS_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xa030)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_SECURE (0x0) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_DUAL (0x0) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_SCR (0) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_SHIFT)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_RANGE (31:0) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_WOFFSET (0x0) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BS_LINE_STRIDE_0 +#define SDP_RDMA_D_BS_LINE_STRIDE_0 (_MK_ADDR_CONST(0xa034)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_SHIFT)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BS_SURFACE_STRIDE_0 +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xa038)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_SHIFT)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BS_BATCH_STRIDE_0 +#define SDP_RDMA_D_BS_BATCH_STRIDE_0 (_MK_ADDR_CONST(0xa03c)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_SCR (0) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_SHIFT)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_NRDMA_CFG_0 +#define SDP_RDMA_D_NRDMA_CFG_0 (_MK_ADDR_CONST(0xa040)) +#define SDP_RDMA_D_NRDMA_CFG_0_SECURE (0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_DUAL (0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_SCR (0) +#define SDP_RDMA_D_NRDMA_CFG_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_NRDMA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_NRDMA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_NRDMA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_SHIFT)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_RANGE (0:0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_WOFFSET (0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_NO (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_YES (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_SHIFT)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_RANGE (2:1) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_WOFFSET (0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_MUL (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_ALU (_MK_ENUM_CONST(1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_BOTH (_MK_ENUM_CONST(2)) + +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_SHIFT (_MK_SHIFT_CONST(3)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_SHIFT)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_RANGE (3:3) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_WOFFSET (0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_ONE_BYTE (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_TWO_BYTE (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_SHIFT (_MK_SHIFT_CONST(4)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_SHIFT)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_RANGE (4:4) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_WOFFSET (0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_PER_KERNEL (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_PER_ELEMENT \ + (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_SHIFT)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_RANGE (5:5) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_WOFFSET (0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register SDP_RDMA_D_BN_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xa044)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_SECURE (0x0) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_DUAL (0x0) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_SCR (0) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_SHIFT)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_RANGE (31:5) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_WOFFSET (0x0) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BN_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xa048)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_SECURE (0x0) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_DUAL (0x0) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_SCR (0) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_SHIFT)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_RANGE (31:0) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_WOFFSET (0x0) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BN_LINE_STRIDE_0 +#define SDP_RDMA_D_BN_LINE_STRIDE_0 (_MK_ADDR_CONST(0xa04c)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_SHIFT)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BN_SURFACE_STRIDE_0 +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xa050)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_SHIFT)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_BN_BATCH_STRIDE_0 +#define SDP_RDMA_D_BN_BATCH_STRIDE_0 (_MK_ADDR_CONST(0xa054)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_SCR (0) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_SHIFT)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_ERDMA_CFG_0 +#define SDP_RDMA_D_ERDMA_CFG_0 (_MK_ADDR_CONST(0xa058)) +#define SDP_RDMA_D_ERDMA_CFG_0_SECURE (0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_DUAL (0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_SCR (0) +#define SDP_RDMA_D_ERDMA_CFG_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_ERDMA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_ERDMA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_ERDMA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_SHIFT)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_RANGE (0:0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_WOFFSET (0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_NO (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_YES (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_SHIFT)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_RANGE (2:1) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_WOFFSET (0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_MUL (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_ALU (_MK_ENUM_CONST(1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_BOTH (_MK_ENUM_CONST(2)) + +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_SHIFT (_MK_SHIFT_CONST(3)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_SHIFT)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_RANGE (3:3) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_WOFFSET (0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_ONE_BYTE (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_TWO_BYTE (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_SHIFT (_MK_SHIFT_CONST(4)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_SHIFT)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_RANGE (4:4) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_WOFFSET (0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_PER_KERNEL (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_PER_ELEMENT \ + (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_SHIFT)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_RANGE (5:5) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_WOFFSET (0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register SDP_RDMA_D_EW_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xa05c)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_SECURE (0x0) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_DUAL (0x0) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_SCR (0) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_SHIFT)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_RANGE (31:5) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_WOFFSET (0x0) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_EW_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xa060)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_SECURE (0x0) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_DUAL (0x0) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_SCR (0) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_SHIFT)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_RANGE (31:0) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_WOFFSET (0x0) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_EW_LINE_STRIDE_0 +#define SDP_RDMA_D_EW_LINE_STRIDE_0 (_MK_ADDR_CONST(0xa064)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_SHIFT)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_EW_SURFACE_STRIDE_0 +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xa068)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_SCR (0) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_SHIFT)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_EW_BATCH_STRIDE_0 +#define SDP_RDMA_D_EW_BATCH_STRIDE_0 (_MK_ADDR_CONST(0xa06c)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_SECURE (0x0) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_DUAL (0x0) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_SCR (0) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_SHIFT)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_RANGE (31:5) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_WOFFSET (0x0) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_FEATURE_MODE_CFG_0 +#define SDP_RDMA_D_FEATURE_MODE_CFG_0 (_MK_ADDR_CONST(0xa070)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_SECURE (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_DUAL (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_SCR (0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_RESET_VAL (_MK_MASK_CONST(0x14)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, \ + SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_RANGE (0:0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_WOFFSET (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_OFF (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_ON (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_RANGE (1:1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_WOFFSET (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_OFF (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_ON (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_SHIFT (_MK_SHIFT_CONST(2)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, \ + SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_SHIFT)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_RANGE (3:2) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_WOFFSET (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_DEFAULT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_SHIFT \ + (_MK_SHIFT_CONST(4)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, \ + SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_SHIFT)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_RANGE (5:4) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_WOFFSET (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_DEFAULT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_INT16 \ + (_MK_ENUM_CONST(1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_SHIFT \ + (_MK_SHIFT_CONST(6)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, \ + SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_SHIFT)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_RANGE (7:6) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_WOFFSET (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT (_MK_SHIFT_CONST(8)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_RANGE (12:8) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_WOFFSET (0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_SRC_DMA_CFG_0 +#define SDP_RDMA_D_SRC_DMA_CFG_0 (_MK_ADDR_CONST(0xa074)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SECURE (0x0) +#define SDP_RDMA_D_SRC_DMA_CFG_0_DUAL (0x0) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SCR (0) +#define SDP_RDMA_D_SRC_DMA_CFG_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_SRC_DMA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_RANGE (0:0) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_WOFFSET (0x0) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0 +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0 (_MK_ADDR_CONST(0xa078)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_SECURE (0x0) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_DUAL (0x0) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_SCR (0) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_RANGE (31:0) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_WOFFSET (0x0) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_STATUS_INF_INPUT_NUM_0 +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0 (_MK_ADDR_CONST(0xa07c)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_SECURE (0x0) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_DUAL (0x0) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_SCR (0) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_RANGE (31:0) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_WOFFSET (0x0) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_PERF_ENABLE_0 +#define SDP_RDMA_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0xa080)) +#define SDP_RDMA_D_PERF_ENABLE_0_SECURE (0x0) +#define SDP_RDMA_D_PERF_ENABLE_0_DUAL (0x0) +#define SDP_RDMA_D_PERF_ENABLE_0_SCR (0) +#define SDP_RDMA_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_RANGE (0:0) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_WOFFSET (0x0) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_INIT_ENUM (NO) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_NO (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_YES (_MK_ENUM_CONST(1)) + +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT \ + (_MK_SHIFT_CONST(1)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_FIELD \ + (_MK_FIELD_CONST(0x1, \ + SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_RANGE (1:1) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_WOFFSET (0x0) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_INIT_ENUM (NO) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_NO (_MK_ENUM_CONST(0)) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_YES \ + (_MK_ENUM_CONST(1)) + + +// Register SDP_RDMA_D_PERF_MRDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0 (_MK_ADDR_CONST(0xa084)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_SECURE (0x0) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_DUAL (0x0) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_SCR (0) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_SHIFT)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_RANGE (31:0) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_WOFFSET (0x0) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_PERF_BRDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0 (_MK_ADDR_CONST(0xa088)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_SECURE (0x0) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_DUAL (0x0) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_SCR (0) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_SHIFT)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_RANGE (31:0) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_WOFFSET (0x0) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_PERF_NRDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0 (_MK_ADDR_CONST(0xa08c)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_SECURE (0x0) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_DUAL (0x0) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_SCR (0) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_SHIFT)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_RANGE (31:0) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_WOFFSET (0x0) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_RDMA_D_PERF_ERDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0 (_MK_ADDR_CONST(0xa090)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_SECURE (0x0) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_DUAL (0x0) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_SCR (0) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_WORD_COUNT (0x1) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_SHIFT)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_RANGE (31:0) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_WOFFSET (0x0) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_STATUS_0 +#define SDP_S_STATUS_0 (_MK_ADDR_CONST(0xb000)) +#define SDP_S_STATUS_0_SECURE (0x0) +#define SDP_S_STATUS_0_DUAL (0x0) +#define SDP_S_STATUS_0_SCR (0) +#define SDP_S_STATUS_0_WORD_COUNT (0x1) +#define SDP_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define SDP_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define SDP_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_S_STATUS_0_STATUS_0_SHIFT)) +#define SDP_S_STATUS_0_STATUS_0_RANGE (1:0) +#define SDP_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define SDP_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define SDP_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define SDP_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define SDP_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define SDP_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define SDP_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_S_STATUS_0_STATUS_1_SHIFT)) +#define SDP_S_STATUS_0_STATUS_1_RANGE (17:16) +#define SDP_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define SDP_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define SDP_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define SDP_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define SDP_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register SDP_S_POINTER_0 +#define SDP_S_POINTER_0 (_MK_ADDR_CONST(0xb004)) +#define SDP_S_POINTER_0_SECURE (0x0) +#define SDP_S_POINTER_0_DUAL (0x0) +#define SDP_S_POINTER_0_SCR (0) +#define SDP_S_POINTER_0_WORD_COUNT (0x1) +#define SDP_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define SDP_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define SDP_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define SDP_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_POINTER_0_PRODUCER_SHIFT)) +#define SDP_S_POINTER_0_PRODUCER_RANGE (0:0) +#define SDP_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define SDP_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define SDP_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define SDP_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define SDP_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define SDP_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_POINTER_0_CONSUMER_SHIFT)) +#define SDP_S_POINTER_0_CONSUMER_RANGE (16:16) +#define SDP_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define SDP_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define SDP_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define SDP_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register SDP_S_LUT_ACCESS_CFG_0 +#define SDP_S_LUT_ACCESS_CFG_0 (_MK_ADDR_CONST(0xb008)) +#define SDP_S_LUT_ACCESS_CFG_0_SECURE (0x0) +#define SDP_S_LUT_ACCESS_CFG_0_DUAL (0x0) +#define SDP_S_LUT_ACCESS_CFG_0_SCR (0) +#define SDP_S_LUT_ACCESS_CFG_0_WORD_COUNT (0x1) +#define SDP_S_LUT_ACCESS_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_RESET_MASK (_MK_MASK_CONST(0x303ff)) +#define SDP_S_LUT_ACCESS_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_READ_MASK (_MK_MASK_CONST(0x303ff)) +#define SDP_S_LUT_ACCESS_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x303ff)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_FIELD \ + (_MK_FIELD_CONST(0x3ff, SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_RANGE (9:0) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_WOFFSET (0x0) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_DEFAULT_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT (_MK_SHIFT_CONST(16)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_RANGE (16:16) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_WOFFSET (0x0) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_INIT_ENUM (LE) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LE (_MK_ENUM_CONST(0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LO (_MK_ENUM_CONST(1)) + +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT (_MK_SHIFT_CONST(17)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_RANGE (17:17) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_WOFFSET (0x0) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_INIT_ENUM (READ) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_READ (_MK_ENUM_CONST(0)) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_WRITE (_MK_ENUM_CONST(1)) + + +// Register SDP_S_LUT_ACCESS_DATA_0 +#define SDP_S_LUT_ACCESS_DATA_0 (_MK_ADDR_CONST(0xb00c)) +#define SDP_S_LUT_ACCESS_DATA_0_SECURE (0x0) +#define SDP_S_LUT_ACCESS_DATA_0_DUAL (0x0) +#define SDP_S_LUT_ACCESS_DATA_0_SCR (0) +#define SDP_S_LUT_ACCESS_DATA_0_WORD_COUNT (0x1) +#define SDP_S_LUT_ACCESS_DATA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_DATA_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_ACCESS_DATA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_DATA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_DATA_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_ACCESS_DATA_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_FIELD \ + (_MK_FIELD_CONST(0xffff, SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_RANGE (15:0) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_WOFFSET (0x0) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_CFG_0 +#define SDP_S_LUT_CFG_0 (_MK_ADDR_CONST(0xb010)) +#define SDP_S_LUT_CFG_0_SECURE (0x0) +#define SDP_S_LUT_CFG_0_DUAL (0x0) +#define SDP_S_LUT_CFG_0_SCR (0) +#define SDP_S_LUT_CFG_0_WORD_COUNT (0x1) +#define SDP_S_LUT_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_RESET_MASK (_MK_MASK_CONST(0x71)) +#define SDP_S_LUT_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_READ_MASK (_MK_MASK_CONST(0x71)) +#define SDP_S_LUT_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x71)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_RANGE (0:0) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_WOFFSET (0x0) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_INIT_ENUM (EXPONENT) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_EXPONENT (_MK_ENUM_CONST(0)) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_LINEAR (_MK_ENUM_CONST(1)) + +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT (_MK_SHIFT_CONST(4)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_RANGE (4:4) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_WOFFSET (0x0) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LE (_MK_ENUM_CONST(0)) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LO (_MK_ENUM_CONST(1)) + +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_RANGE (5:5) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_WOFFSET (0x0) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LE (_MK_ENUM_CONST(0)) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LO (_MK_ENUM_CONST(1)) + +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT (_MK_SHIFT_CONST(6)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_RANGE (6:6) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_WOFFSET (0x0) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LE (_MK_ENUM_CONST(0)) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LO (_MK_ENUM_CONST(1)) + + +// Register SDP_S_LUT_INFO_0 +#define SDP_S_LUT_INFO_0 (_MK_ADDR_CONST(0xb014)) +#define SDP_S_LUT_INFO_0_SECURE (0x0) +#define SDP_S_LUT_INFO_0_DUAL (0x0) +#define SDP_S_LUT_INFO_0_SCR (0) +#define SDP_S_LUT_INFO_0_WORD_COUNT (0x1) +#define SDP_S_LUT_INFO_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_RESET_MASK (_MK_MASK_CONST(0xffffff)) +#define SDP_S_LUT_INFO_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_READ_MASK (_MK_MASK_CONST(0xffffff)) +#define SDP_S_LUT_INFO_0_WRITE_MASK (_MK_MASK_CONST(0xffffff)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xff, SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_RANGE (7:0) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_WOFFSET (0x0) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT (_MK_SHIFT_CONST(8)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_FIELD \ + (_MK_FIELD_CONST(0xff, SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_RANGE (15:8) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_WOFFSET (0x0) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT (_MK_SHIFT_CONST(16)) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_FIELD \ + (_MK_FIELD_CONST(0xff, SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT)) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_RANGE (23:16) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_WOFFSET (0x0) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LE_START_0 +#define SDP_S_LUT_LE_START_0 (_MK_ADDR_CONST(0xb018)) +#define SDP_S_LUT_LE_START_0_SECURE (0x0) +#define SDP_S_LUT_LE_START_0_DUAL (0x0) +#define SDP_S_LUT_LE_START_0_SCR (0) +#define SDP_S_LUT_LE_START_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LE_START_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_START_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_START_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_START_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_START_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_START_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_S_LUT_LE_START_0_LUT_LE_START_SHIFT)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_RANGE (31:0) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_WOFFSET (0x0) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LE_END_0 +#define SDP_S_LUT_LE_END_0 (_MK_ADDR_CONST(0xb01c)) +#define SDP_S_LUT_LE_END_0_SECURE (0x0) +#define SDP_S_LUT_LE_END_0_DUAL (0x0) +#define SDP_S_LUT_LE_END_0_SCR (0) +#define SDP_S_LUT_LE_END_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LE_END_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_END_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_END_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_END_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_END_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_END_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_FIELD \ + (_MK_FIELD_CONST(0xffffffff, SDP_S_LUT_LE_END_0_LUT_LE_END_SHIFT)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_RANGE (31:0) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_WOFFSET (0x0) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LO_START_0 +#define SDP_S_LUT_LO_START_0 (_MK_ADDR_CONST(0xb020)) +#define SDP_S_LUT_LO_START_0_SECURE (0x0) +#define SDP_S_LUT_LO_START_0_DUAL (0x0) +#define SDP_S_LUT_LO_START_0_SCR (0) +#define SDP_S_LUT_LO_START_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LO_START_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_START_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_START_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_START_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_START_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_START_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_S_LUT_LO_START_0_LUT_LO_START_SHIFT)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_RANGE (31:0) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_WOFFSET (0x0) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LO_END_0 +#define SDP_S_LUT_LO_END_0 (_MK_ADDR_CONST(0xb024)) +#define SDP_S_LUT_LO_END_0_SECURE (0x0) +#define SDP_S_LUT_LO_END_0_DUAL (0x0) +#define SDP_S_LUT_LO_END_0_SCR (0) +#define SDP_S_LUT_LO_END_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LO_END_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_END_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_END_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_END_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_END_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_END_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_FIELD \ + (_MK_FIELD_CONST(0xffffffff, SDP_S_LUT_LO_END_0_LUT_LO_END_SHIFT)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_RANGE (31:0) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_WOFFSET (0x0) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LE_SLOPE_SCALE_0 +#define SDP_S_LUT_LE_SLOPE_SCALE_0 (_MK_ADDR_CONST(0xb028)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_SECURE (0x0) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_DUAL (0x0) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_SCR (0) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_RANGE (15:0) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_WOFFSET (0x0) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_RANGE (31:16) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_WOFFSET (0x0) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LE_SLOPE_SHIFT_0 +#define SDP_S_LUT_LE_SLOPE_SHIFT_0 (_MK_ADDR_CONST(0xb02c)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_SECURE (0x0) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_DUAL (0x0) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_SCR (0) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_RESET_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_READ_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_WRITE_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_RANGE (4:0) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_WOFFSET (0x0) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_RANGE (9:5) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_WOFFSET (0x0) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LO_SLOPE_SCALE_0 +#define SDP_S_LUT_LO_SLOPE_SCALE_0 (_MK_ADDR_CONST(0xb030)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_SECURE (0x0) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_DUAL (0x0) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_SCR (0) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_RANGE (15:0) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_WOFFSET (0x0) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_RANGE (31:16) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_WOFFSET (0x0) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_S_LUT_LO_SLOPE_SHIFT_0 +#define SDP_S_LUT_LO_SLOPE_SHIFT_0 (_MK_ADDR_CONST(0xb034)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_SECURE (0x0) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_DUAL (0x0) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_SCR (0) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_WORD_COUNT (0x1) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_RESET_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_READ_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_WRITE_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_RANGE (4:0) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_WOFFSET (0x0) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_RANGE (9:5) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_WOFFSET (0x0) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_OP_ENABLE_0 +#define SDP_D_OP_ENABLE_0 (_MK_ADDR_CONST(0xb038)) +#define SDP_D_OP_ENABLE_0_SECURE (0x0) +#define SDP_D_OP_ENABLE_0_DUAL (0x0) +#define SDP_D_OP_ENABLE_0_SCR (0) +#define SDP_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define SDP_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define SDP_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define SDP_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define SDP_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define SDP_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define SDP_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register SDP_D_DATA_CUBE_WIDTH_0 +#define SDP_D_DATA_CUBE_WIDTH_0 (_MK_ADDR_CONST(0xb03c)) +#define SDP_D_DATA_CUBE_WIDTH_0_SECURE (0x0) +#define SDP_D_DATA_CUBE_WIDTH_0_DUAL (0x0) +#define SDP_D_DATA_CUBE_WIDTH_0_SCR (0) +#define SDP_D_DATA_CUBE_WIDTH_0_WORD_COUNT (0x1) +#define SDP_D_DATA_CUBE_WIDTH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_WIDTH_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_WIDTH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_WIDTH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_WIDTH_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_WIDTH_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, SDP_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_RANGE (12:0) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_WOFFSET (0x0) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_DEFAULT_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DATA_CUBE_HEIGHT_0 +#define SDP_D_DATA_CUBE_HEIGHT_0 (_MK_ADDR_CONST(0xb040)) +#define SDP_D_DATA_CUBE_HEIGHT_0_SECURE (0x0) +#define SDP_D_DATA_CUBE_HEIGHT_0_DUAL (0x0) +#define SDP_D_DATA_CUBE_HEIGHT_0_SCR (0) +#define SDP_D_DATA_CUBE_HEIGHT_0_WORD_COUNT (0x1) +#define SDP_D_DATA_CUBE_HEIGHT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_HEIGHT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_HEIGHT_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_RANGE (12:0) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_WOFFSET (0x0) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_DEFAULT_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DATA_CUBE_CHANNEL_0 +#define SDP_D_DATA_CUBE_CHANNEL_0 (_MK_ADDR_CONST(0xb044)) +#define SDP_D_DATA_CUBE_CHANNEL_0_SECURE (0x0) +#define SDP_D_DATA_CUBE_CHANNEL_0_DUAL (0x0) +#define SDP_D_DATA_CUBE_CHANNEL_0_SCR (0) +#define SDP_D_DATA_CUBE_CHANNEL_0_WORD_COUNT (0x1) +#define SDP_D_DATA_CUBE_CHANNEL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_CHANNEL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_CHANNEL_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_RANGE (12:0) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_WOFFSET (0x0) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DST_BASE_ADDR_LOW_0 +#define SDP_D_DST_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xb048)) +#define SDP_D_DST_BASE_ADDR_LOW_0_SECURE (0x0) +#define SDP_D_DST_BASE_ADDR_LOW_0_DUAL (0x0) +#define SDP_D_DST_BASE_ADDR_LOW_0_SCR (0) +#define SDP_D_DST_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define SDP_D_DST_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_RANGE (31:5) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_WOFFSET (0x0) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DST_BASE_ADDR_HIGH_0 +#define SDP_D_DST_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xb04c)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_SECURE (0x0) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DUAL (0x0) +#define SDP_D_DST_BASE_ADDR_HIGH_0_SCR (0) +#define SDP_D_DST_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define SDP_D_DST_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_RANGE (31:0) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_WOFFSET (0x0) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DST_LINE_STRIDE_0 +#define SDP_D_DST_LINE_STRIDE_0 (_MK_ADDR_CONST(0xb050)) +#define SDP_D_DST_LINE_STRIDE_0_SECURE (0x0) +#define SDP_D_DST_LINE_STRIDE_0_DUAL (0x0) +#define SDP_D_DST_LINE_STRIDE_0_SCR (0) +#define SDP_D_DST_LINE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_D_DST_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_RANGE (31:5) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_WOFFSET (0x0) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DST_SURFACE_STRIDE_0 +#define SDP_D_DST_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xb054)) +#define SDP_D_DST_SURFACE_STRIDE_0_SECURE (0x0) +#define SDP_D_DST_SURFACE_STRIDE_0_DUAL (0x0) +#define SDP_D_DST_SURFACE_STRIDE_0_SCR (0) +#define SDP_D_DST_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define SDP_D_DST_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_SURFACE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_SURFACE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_SURFACE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_RANGE (31:5) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_WOFFSET (0x0) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BS_CFG_0 +#define SDP_D_DP_BS_CFG_0 (_MK_ADDR_CONST(0xb058)) +#define SDP_D_DP_BS_CFG_0_SECURE (0x0) +#define SDP_D_DP_BS_CFG_0_DUAL (0x0) +#define SDP_D_DP_BS_CFG_0_SCR (0) +#define SDP_D_DP_BS_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_BS_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_RESET_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_BS_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_READ_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_BS_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_BYPASS_SHIFT)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_RANGE (0:0) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_SHIFT)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_RANGE (1:1) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SHIFT (_MK_SHIFT_CONST(2)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SHIFT)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_RANGE (3:2) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_WOFFSET (0x0) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_MAX (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_MIN (_MK_ENUM_CONST(1)) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SUM (_MK_ENUM_CONST(2)) + +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_SHIFT (_MK_SHIFT_CONST(4)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_SHIFT)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_RANGE (4:4) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_SHIFT)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_RANGE (5:5) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_WOFFSET (0x0) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_SHIFT (_MK_SHIFT_CONST(6)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_SHIFT)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_RANGE (6:6) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_YES (_MK_ENUM_CONST(1)) + + +// Register SDP_D_DP_BS_ALU_CFG_0 +#define SDP_D_DP_BS_ALU_CFG_0 (_MK_ADDR_CONST(0xb05c)) +#define SDP_D_DP_BS_ALU_CFG_0_SECURE (0x0) +#define SDP_D_DP_BS_ALU_CFG_0_DUAL (0x0) +#define SDP_D_DP_BS_ALU_CFG_0_SCR (0) +#define SDP_D_DP_BS_ALU_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_BS_ALU_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3f01)) +#define SDP_D_DP_BS_ALU_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_READ_MASK (_MK_MASK_CONST(0x3f01)) +#define SDP_D_DP_BS_ALU_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3f01)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_SHIFT)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_RANGE (0:0) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_WOFFSET (0x0) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_REG (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_MEM (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_SHIFT (_MK_SHIFT_CONST(8)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_SHIFT)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_RANGE (13:8) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_WOFFSET (0x0) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BS_ALU_SRC_VALUE_0 +#define SDP_D_DP_BS_ALU_SRC_VALUE_0 (_MK_ADDR_CONST(0xb060)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_SECURE (0x0) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_DUAL (0x0) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_SCR (0) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_SHIFT)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_RANGE (15:0) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_WOFFSET (0x0) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BS_MUL_CFG_0 +#define SDP_D_DP_BS_MUL_CFG_0 (_MK_ADDR_CONST(0xb064)) +#define SDP_D_DP_BS_MUL_CFG_0_SECURE (0x0) +#define SDP_D_DP_BS_MUL_CFG_0_DUAL (0x0) +#define SDP_D_DP_BS_MUL_CFG_0_SCR (0) +#define SDP_D_DP_BS_MUL_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_BS_MUL_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_RESET_MASK (_MK_MASK_CONST(0xff01)) +#define SDP_D_DP_BS_MUL_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_READ_MASK (_MK_MASK_CONST(0xff01)) +#define SDP_D_DP_BS_MUL_CFG_0_WRITE_MASK (_MK_MASK_CONST(0xff01)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_SHIFT)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_RANGE (0:0) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_WOFFSET (0x0) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_REG (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_MEM (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_SHIFT (_MK_SHIFT_CONST(8)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_FIELD \ + (_MK_FIELD_CONST(0xff, \ + SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_SHIFT)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_RANGE (15:8) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_WOFFSET (0x0) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BS_MUL_SRC_VALUE_0 +#define SDP_D_DP_BS_MUL_SRC_VALUE_0 (_MK_ADDR_CONST(0xb068)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_SECURE (0x0) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_DUAL (0x0) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_SCR (0) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_SHIFT)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_RANGE (15:0) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_WOFFSET (0x0) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BN_CFG_0 +#define SDP_D_DP_BN_CFG_0 (_MK_ADDR_CONST(0xb06c)) +#define SDP_D_DP_BN_CFG_0_SECURE (0x0) +#define SDP_D_DP_BN_CFG_0_DUAL (0x0) +#define SDP_D_DP_BN_CFG_0_SCR (0) +#define SDP_D_DP_BN_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_BN_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_RESET_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_BN_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_READ_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_BN_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_BYPASS_SHIFT)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_RANGE (0:0) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_SHIFT)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_RANGE (1:1) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SHIFT (_MK_SHIFT_CONST(2)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SHIFT)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_RANGE (3:2) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_WOFFSET (0x0) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_MAX (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_MIN (_MK_ENUM_CONST(1)) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SUM (_MK_ENUM_CONST(2)) + +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_SHIFT (_MK_SHIFT_CONST(4)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_SHIFT)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_RANGE (4:4) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_SHIFT)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_RANGE (5:5) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_WOFFSET (0x0) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_SHIFT (_MK_SHIFT_CONST(6)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_SHIFT)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_RANGE (6:6) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_YES (_MK_ENUM_CONST(1)) + + +// Register SDP_D_DP_BN_ALU_CFG_0 +#define SDP_D_DP_BN_ALU_CFG_0 (_MK_ADDR_CONST(0xb070)) +#define SDP_D_DP_BN_ALU_CFG_0_SECURE (0x0) +#define SDP_D_DP_BN_ALU_CFG_0_DUAL (0x0) +#define SDP_D_DP_BN_ALU_CFG_0_SCR (0) +#define SDP_D_DP_BN_ALU_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_BN_ALU_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3f01)) +#define SDP_D_DP_BN_ALU_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_READ_MASK (_MK_MASK_CONST(0x3f01)) +#define SDP_D_DP_BN_ALU_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3f01)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_SHIFT)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_RANGE (0:0) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_WOFFSET (0x0) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_REG (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_MEM (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_SHIFT (_MK_SHIFT_CONST(8)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_SHIFT)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_RANGE (13:8) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_WOFFSET (0x0) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BN_ALU_SRC_VALUE_0 +#define SDP_D_DP_BN_ALU_SRC_VALUE_0 (_MK_ADDR_CONST(0xb074)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_SECURE (0x0) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_DUAL (0x0) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_SCR (0) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_SHIFT)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_RANGE (15:0) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_WOFFSET (0x0) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BN_MUL_CFG_0 +#define SDP_D_DP_BN_MUL_CFG_0 (_MK_ADDR_CONST(0xb078)) +#define SDP_D_DP_BN_MUL_CFG_0_SECURE (0x0) +#define SDP_D_DP_BN_MUL_CFG_0_DUAL (0x0) +#define SDP_D_DP_BN_MUL_CFG_0_SCR (0) +#define SDP_D_DP_BN_MUL_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_BN_MUL_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_RESET_MASK (_MK_MASK_CONST(0xff01)) +#define SDP_D_DP_BN_MUL_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_READ_MASK (_MK_MASK_CONST(0xff01)) +#define SDP_D_DP_BN_MUL_CFG_0_WRITE_MASK (_MK_MASK_CONST(0xff01)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_SHIFT)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_RANGE (0:0) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_WOFFSET (0x0) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_REG (_MK_ENUM_CONST(0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_MEM (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_SHIFT (_MK_SHIFT_CONST(8)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_FIELD \ + (_MK_FIELD_CONST(0xff, \ + SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_SHIFT)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_RANGE (15:8) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_WOFFSET (0x0) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_BN_MUL_SRC_VALUE_0 +#define SDP_D_DP_BN_MUL_SRC_VALUE_0 (_MK_ADDR_CONST(0xb07c)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_SECURE (0x0) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_DUAL (0x0) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_SCR (0) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_SHIFT)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_RANGE (15:0) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_WOFFSET (0x0) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_CFG_0 +#define SDP_D_DP_EW_CFG_0 (_MK_ADDR_CONST(0xb080)) +#define SDP_D_DP_EW_CFG_0_SECURE (0x0) +#define SDP_D_DP_EW_CFG_0_DUAL (0x0) +#define SDP_D_DP_EW_CFG_0_SCR (0) +#define SDP_D_DP_EW_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_RESET_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_EW_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_READ_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_EW_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x7f)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_BYPASS_SHIFT)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_RANGE (0:0) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_SHIFT)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_RANGE (1:1) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SHIFT (_MK_SHIFT_CONST(2)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SHIFT)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_RANGE (3:2) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_WOFFSET (0x0) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_MAX (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_MIN (_MK_ENUM_CONST(1)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SUM (_MK_ENUM_CONST(2)) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_EQL (_MK_ENUM_CONST(3)) + +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_SHIFT (_MK_SHIFT_CONST(4)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_SHIFT)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_RANGE (4:4) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_SHIFT)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_RANGE (5:5) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_WOFFSET (0x0) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_SHIFT (_MK_SHIFT_CONST(6)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_SHIFT)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_RANGE (6:6) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_YES (_MK_ENUM_CONST(1)) + + +// Register SDP_D_DP_EW_ALU_CFG_0 +#define SDP_D_DP_EW_ALU_CFG_0 (_MK_ADDR_CONST(0xb084)) +#define SDP_D_DP_EW_ALU_CFG_0_SECURE (0x0) +#define SDP_D_DP_EW_ALU_CFG_0_DUAL (0x0) +#define SDP_D_DP_EW_ALU_CFG_0_SCR (0) +#define SDP_D_DP_EW_ALU_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_ALU_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_EW_ALU_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_EW_ALU_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_SHIFT)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_RANGE (0:0) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_WOFFSET (0x0) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_REG (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_MEM (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_SHIFT)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_RANGE (1:1) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_YES (_MK_ENUM_CONST(1)) + + +// Register SDP_D_DP_EW_ALU_SRC_VALUE_0 +#define SDP_D_DP_EW_ALU_SRC_VALUE_0 (_MK_ADDR_CONST(0xb088)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_SCR (0) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_SHIFT)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_RANGE (31:0) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_WOFFSET (0x0) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0 +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0 (_MK_ADDR_CONST(0xb08c)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_SCR (0) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_SHIFT)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_RANGE (31:0) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_WOFFSET (0x0) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0 +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0 (_MK_ADDR_CONST(0xb090)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_SCR (0) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_SHIFT)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_RANGE (15:0) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_WOFFSET (0x0) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0 +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0 (_MK_ADDR_CONST(0xb094)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_SCR (0) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_RESET_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_WRITE_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_SHIFT)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_RANGE (5:0) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_WOFFSET \ + (0x0) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_MUL_CFG_0 +#define SDP_D_DP_EW_MUL_CFG_0 (_MK_ADDR_CONST(0xb098)) +#define SDP_D_DP_EW_MUL_CFG_0_SECURE (0x0) +#define SDP_D_DP_EW_MUL_CFG_0_DUAL (0x0) +#define SDP_D_DP_EW_MUL_CFG_0_SCR (0) +#define SDP_D_DP_EW_MUL_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_MUL_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_EW_MUL_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_EW_MUL_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_SHIFT)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_RANGE (0:0) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_WOFFSET (0x0) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_REG (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_MEM (_MK_ENUM_CONST(1)) + +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_SHIFT)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_RANGE (1:1) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_WOFFSET (0x0) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_NO (_MK_ENUM_CONST(0)) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_YES (_MK_ENUM_CONST(1)) + + +// Register SDP_D_DP_EW_MUL_SRC_VALUE_0 +#define SDP_D_DP_EW_MUL_SRC_VALUE_0 (_MK_ADDR_CONST(0xb09c)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_SCR (0) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_SHIFT)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_RANGE (31:0) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_WOFFSET (0x0) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0 +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0 (_MK_ADDR_CONST(0xb0a0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_SCR (0) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_SHIFT)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_RANGE (31:0) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_WOFFSET (0x0) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0 +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0 (_MK_ADDR_CONST(0xb0a4)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_SCR (0) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_SHIFT)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_RANGE (15:0) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_WOFFSET (0x0) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0 +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0 (_MK_ADDR_CONST(0xb0a8)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_SCR (0) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_RESET_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_WRITE_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_SHIFT)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_RANGE (5:0) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_WOFFSET \ + (0x0) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DP_EW_TRUNCATE_VALUE_0 +#define SDP_D_DP_EW_TRUNCATE_VALUE_0 (_MK_ADDR_CONST(0xb0ac)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_SECURE (0x0) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_DUAL (0x0) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_SCR (0) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_WORD_COUNT (0x1) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_RESET_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_READ_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_WRITE_MASK (_MK_MASK_CONST(0x3ff)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_SHIFT)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_RANGE (9:0) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_WOFFSET (0x0) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_FEATURE_MODE_CFG_0 +#define SDP_D_FEATURE_MODE_CFG_0 (_MK_ADDR_CONST(0xb0b0)) +#define SDP_D_FEATURE_MODE_CFG_0_SECURE (0x0) +#define SDP_D_FEATURE_MODE_CFG_0_DUAL (0x0) +#define SDP_D_FEATURE_MODE_CFG_0_SCR (0) +#define SDP_D_FEATURE_MODE_CFG_0_WORD_COUNT (0x1) +#define SDP_D_FEATURE_MODE_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1f0f)) +#define SDP_D_FEATURE_MODE_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_READ_MASK (_MK_MASK_CONST(0x1f0f)) +#define SDP_D_FEATURE_MODE_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1f0f)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_RANGE (0:0) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_WOFFSET (0x0) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_OFF (_MK_ENUM_CONST(0)) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_ON (_MK_ENUM_CONST(1)) + +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_SHIFT)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_RANGE (1:1) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_WOFFSET (0x0) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_MEM (_MK_ENUM_CONST(0)) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_PDP (_MK_ENUM_CONST(1)) + +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT (_MK_SHIFT_CONST(2)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_RANGE (2:2) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_WOFFSET (0x0) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_OFF (_MK_ENUM_CONST(0)) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_ON (_MK_ENUM_CONST(1)) + +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_SHIFT (_MK_SHIFT_CONST(3)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_SHIFT)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_RANGE (3:3) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_WOFFSET (0x0) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_INIT_ENUM (DISABLE) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_DISABLE (_MK_ENUM_CONST(0)) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_ENABLE (_MK_ENUM_CONST(1)) + +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT (_MK_SHIFT_CONST(8)) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_FIELD \ + (_MK_FIELD_CONST(0x1f, SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT)) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_RANGE (12:8) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_WOFFSET (0x0) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DST_DMA_CFG_0 +#define SDP_D_DST_DMA_CFG_0 (_MK_ADDR_CONST(0xb0b4)) +#define SDP_D_DST_DMA_CFG_0_SECURE (0x0) +#define SDP_D_DST_DMA_CFG_0_DUAL (0x0) +#define SDP_D_DST_DMA_CFG_0_SCR (0) +#define SDP_D_DST_DMA_CFG_0_WORD_COUNT (0x1) +#define SDP_D_DST_DMA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_DMA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DST_DMA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_DMA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_DMA_CFG_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DST_DMA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_RANGE (0:0) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_WOFFSET (0x0) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register SDP_D_DST_BATCH_STRIDE_0 +#define SDP_D_DST_BATCH_STRIDE_0 (_MK_ADDR_CONST(0xb0b8)) +#define SDP_D_DST_BATCH_STRIDE_0_SECURE (0x0) +#define SDP_D_DST_BATCH_STRIDE_0_DUAL (0x0) +#define SDP_D_DST_BATCH_STRIDE_0_SCR (0) +#define SDP_D_DST_BATCH_STRIDE_0_WORD_COUNT (0x1) +#define SDP_D_DST_BATCH_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BATCH_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_BATCH_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BATCH_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BATCH_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_BATCH_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_SHIFT)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_RANGE (31:5) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_WOFFSET (0x0) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_DATA_FORMAT_0 +#define SDP_D_DATA_FORMAT_0 (_MK_ADDR_CONST(0xb0bc)) +#define SDP_D_DATA_FORMAT_0_SECURE (0x0) +#define SDP_D_DATA_FORMAT_0_DUAL (0x0) +#define SDP_D_DATA_FORMAT_0_SCR (0) +#define SDP_D_DATA_FORMAT_0_WORD_COUNT (0x1) +#define SDP_D_DATA_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0xf)) +#define SDP_D_DATA_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_READ_MASK (_MK_MASK_CONST(0xf)) +#define SDP_D_DATA_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0xf)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_D_DATA_FORMAT_0_PROC_PRECISION_SHIFT)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_RANGE (1:0) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_WOFFSET (0x0) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_FP16 (_MK_ENUM_CONST(2)) + +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_SHIFT (_MK_SHIFT_CONST(2)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, SDP_D_DATA_FORMAT_0_OUT_PRECISION_SHIFT)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_RANGE (3:2) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_WOFFSET (0x0) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_FP16 (_MK_ENUM_CONST(2)) + + +// Register SDP_D_CVT_OFFSET_0 +#define SDP_D_CVT_OFFSET_0 (_MK_ADDR_CONST(0xb0c0)) +#define SDP_D_CVT_OFFSET_0_SECURE (0x0) +#define SDP_D_CVT_OFFSET_0_DUAL (0x0) +#define SDP_D_CVT_OFFSET_0_SCR (0) +#define SDP_D_CVT_OFFSET_0_WORD_COUNT (0x1) +#define SDP_D_CVT_OFFSET_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_OFFSET_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_CVT_OFFSET_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_OFFSET_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_OFFSET_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_CVT_OFFSET_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xffffffff, SDP_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_RANGE (31:0) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_WOFFSET (0x0) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_CVT_SCALE_0 +#define SDP_D_CVT_SCALE_0 (_MK_ADDR_CONST(0xb0c4)) +#define SDP_D_CVT_SCALE_0_SECURE (0x0) +#define SDP_D_CVT_SCALE_0_DUAL (0x0) +#define SDP_D_CVT_SCALE_0_SCR (0) +#define SDP_D_CVT_SCALE_0_WORD_COUNT (0x1) +#define SDP_D_CVT_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_CVT_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_CVT_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, SDP_D_CVT_SCALE_0_CVT_SCALE_SHIFT)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_RANGE (15:0) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_WOFFSET (0x0) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_CVT_SHIFT_0 +#define SDP_D_CVT_SHIFT_0 (_MK_ADDR_CONST(0xb0c8)) +#define SDP_D_CVT_SHIFT_0_SECURE (0x0) +#define SDP_D_CVT_SHIFT_0_DUAL (0x0) +#define SDP_D_CVT_SHIFT_0_SCR (0) +#define SDP_D_CVT_SHIFT_0_WORD_COUNT (0x1) +#define SDP_D_CVT_SHIFT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SHIFT_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_D_CVT_SHIFT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SHIFT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SHIFT_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_D_CVT_SHIFT_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x3f, SDP_D_CVT_SHIFT_0_CVT_SHIFT_SHIFT)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_RANGE (5:0) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_WOFFSET (0x0) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_DEFAULT_MASK (_MK_MASK_CONST(0x3f)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_STATUS_0 +#define SDP_D_STATUS_0 (_MK_ADDR_CONST(0xb0cc)) +#define SDP_D_STATUS_0_SECURE (0x0) +#define SDP_D_STATUS_0_DUAL (0x0) +#define SDP_D_STATUS_0_SCR (0) +#define SDP_D_STATUS_0_WORD_COUNT (0x1) +#define SDP_D_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_STATUS_0_STATUS_UNEQUAL_SHIFT)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_RANGE (0:0) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_WOFFSET (0x0) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_STATUS_NAN_INPUT_NUM_0 +#define SDP_D_STATUS_NAN_INPUT_NUM_0 (_MK_ADDR_CONST(0xb0d0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_SECURE (0x0) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_DUAL (0x0) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_SCR (0) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_WORD_COUNT (0x1) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_RANGE (31:0) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_WOFFSET (0x0) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_STATUS_INF_INPUT_NUM_0 +#define SDP_D_STATUS_INF_INPUT_NUM_0 (_MK_ADDR_CONST(0xb0d4)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_SECURE (0x0) +#define SDP_D_STATUS_INF_INPUT_NUM_0_DUAL (0x0) +#define SDP_D_STATUS_INF_INPUT_NUM_0_SCR (0) +#define SDP_D_STATUS_INF_INPUT_NUM_0_WORD_COUNT (0x1) +#define SDP_D_STATUS_INF_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_RANGE (31:0) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_WOFFSET (0x0) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_STATUS_NAN_OUTPUT_NUM_0 +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0 (_MK_ADDR_CONST(0xb0d8)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_SECURE (0x0) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_DUAL (0x0) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_SCR (0) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_WORD_COUNT (0x1) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_SHIFT)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_RANGE (31:0) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_WOFFSET (0x0) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_PERF_ENABLE_0 +#define SDP_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0xb0dc)) +#define SDP_D_PERF_ENABLE_0_SECURE (0x0) +#define SDP_D_PERF_ENABLE_0_DUAL (0x0) +#define SDP_D_PERF_ENABLE_0_SCR (0) +#define SDP_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define SDP_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0xf)) +#define SDP_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0xf)) +#define SDP_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0xf)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_RANGE (0:0) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_WOFFSET (0x0) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_INIT_ENUM (NO) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_NO (_MK_ENUM_CONST(0)) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_SHIFT (_MK_SHIFT_CONST(1)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_PERF_ENABLE_0_PERF_LUT_EN_SHIFT)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_RANGE (1:1) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_WOFFSET (0x0) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_INIT_ENUM (NO) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_NO (_MK_ENUM_CONST(0)) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_SHIFT (_MK_SHIFT_CONST(2)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_FIELD \ + (_MK_FIELD_CONST(0x1, SDP_D_PERF_ENABLE_0_PERF_SAT_EN_SHIFT)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_RANGE (2:2) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_WOFFSET (0x0) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_INIT_ENUM (NO) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_NO (_MK_ENUM_CONST(0)) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_YES (_MK_ENUM_CONST(1)) + +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT (_MK_SHIFT_CONST(3)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_FIELD \ + (_MK_FIELD_CONST(0x1, \ + SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_RANGE (3:3) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_WOFFSET (0x0) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_INIT_ENUM (NO) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_NO (_MK_ENUM_CONST(0)) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_YES (_MK_ENUM_CONST(1)) + + +// Register SDP_D_PERF_WDMA_WRITE_STALL_0 +#define SDP_D_PERF_WDMA_WRITE_STALL_0 (_MK_ADDR_CONST(0xb0e0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_SECURE (0x0) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_DUAL (0x0) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_SCR (0) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WORD_COUNT (0x1) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_SHIFT)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_RANGE (31:0) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_WOFFSET (0x0) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_PERF_LUT_UFLOW_0 +#define SDP_D_PERF_LUT_UFLOW_0 (_MK_ADDR_CONST(0xb0e4)) +#define SDP_D_PERF_LUT_UFLOW_0_SECURE (0x0) +#define SDP_D_PERF_LUT_UFLOW_0_DUAL (0x0) +#define SDP_D_PERF_LUT_UFLOW_0_SCR (0) +#define SDP_D_PERF_LUT_UFLOW_0_WORD_COUNT (0x1) +#define SDP_D_PERF_LUT_UFLOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_UFLOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_UFLOW_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_SHIFT)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_RANGE (31:0) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_WOFFSET (0x0) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_PERF_LUT_OFLOW_0 +#define SDP_D_PERF_LUT_OFLOW_0 (_MK_ADDR_CONST(0xb0e8)) +#define SDP_D_PERF_LUT_OFLOW_0_SECURE (0x0) +#define SDP_D_PERF_LUT_OFLOW_0_DUAL (0x0) +#define SDP_D_PERF_LUT_OFLOW_0_SCR (0) +#define SDP_D_PERF_LUT_OFLOW_0_WORD_COUNT (0x1) +#define SDP_D_PERF_LUT_OFLOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_OFLOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_OFLOW_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_SHIFT)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_RANGE (31:0) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_WOFFSET (0x0) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_PERF_OUT_SATURATION_0 +#define SDP_D_PERF_OUT_SATURATION_0 (_MK_ADDR_CONST(0xb0ec)) +#define SDP_D_PERF_OUT_SATURATION_0_SECURE (0x0) +#define SDP_D_PERF_OUT_SATURATION_0_DUAL (0x0) +#define SDP_D_PERF_OUT_SATURATION_0_SCR (0) +#define SDP_D_PERF_OUT_SATURATION_0_WORD_COUNT (0x1) +#define SDP_D_PERF_OUT_SATURATION_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_OUT_SATURATION_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_OUT_SATURATION_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_SHIFT)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_RANGE (31:0) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_WOFFSET (0x0) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_PERF_LUT_HYBRID_0 +#define SDP_D_PERF_LUT_HYBRID_0 (_MK_ADDR_CONST(0xb0f0)) +#define SDP_D_PERF_LUT_HYBRID_0_SECURE (0x0) +#define SDP_D_PERF_LUT_HYBRID_0_DUAL (0x0) +#define SDP_D_PERF_LUT_HYBRID_0_SCR (0) +#define SDP_D_PERF_LUT_HYBRID_0_WORD_COUNT (0x1) +#define SDP_D_PERF_LUT_HYBRID_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_HYBRID_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_HYBRID_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_SHIFT)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_RANGE (31:0) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_WOFFSET (0x0) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_PERF_LUT_LE_HIT_0 +#define SDP_D_PERF_LUT_LE_HIT_0 (_MK_ADDR_CONST(0xb0f4)) +#define SDP_D_PERF_LUT_LE_HIT_0_SECURE (0x0) +#define SDP_D_PERF_LUT_LE_HIT_0_DUAL (0x0) +#define SDP_D_PERF_LUT_LE_HIT_0_SCR (0) +#define SDP_D_PERF_LUT_LE_HIT_0_WORD_COUNT (0x1) +#define SDP_D_PERF_LUT_LE_HIT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_LE_HIT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_LE_HIT_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_SHIFT)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_RANGE (31:0) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_WOFFSET (0x0) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register SDP_D_PERF_LUT_LO_HIT_0 +#define SDP_D_PERF_LUT_LO_HIT_0 (_MK_ADDR_CONST(0xb0f8)) +#define SDP_D_PERF_LUT_LO_HIT_0_SECURE (0x0) +#define SDP_D_PERF_LUT_LO_HIT_0_DUAL (0x0) +#define SDP_D_PERF_LUT_LO_HIT_0_SCR (0) +#define SDP_D_PERF_LUT_LO_HIT_0_WORD_COUNT (0x1) +#define SDP_D_PERF_LUT_LO_HIT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_LO_HIT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_LO_HIT_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_SHIFT (_MK_SHIFT_CONST(0)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_SHIFT)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_RANGE (31:0) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_WOFFSET (0x0) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_S_STATUS_0 +#define PDP_RDMA_S_STATUS_0 (_MK_ADDR_CONST(0xc000)) +#define PDP_RDMA_S_STATUS_0_SECURE (0x0) +#define PDP_RDMA_S_STATUS_0_DUAL (0x0) +#define PDP_RDMA_S_STATUS_0_SCR (0) +#define PDP_RDMA_S_STATUS_0_WORD_COUNT (0x1) +#define PDP_RDMA_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define PDP_RDMA_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define PDP_RDMA_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, PDP_RDMA_S_STATUS_0_STATUS_0_SHIFT)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_RANGE (1:0) +#define PDP_RDMA_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define PDP_RDMA_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define PDP_RDMA_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define PDP_RDMA_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define PDP_RDMA_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, PDP_RDMA_S_STATUS_0_STATUS_1_SHIFT)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_RANGE (17:16) +#define PDP_RDMA_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define PDP_RDMA_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define PDP_RDMA_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define PDP_RDMA_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register PDP_RDMA_S_POINTER_0 +#define PDP_RDMA_S_POINTER_0 (_MK_ADDR_CONST(0xc004)) +#define PDP_RDMA_S_POINTER_0_SECURE (0x0) +#define PDP_RDMA_S_POINTER_0_DUAL (0x0) +#define PDP_RDMA_S_POINTER_0_SCR (0) +#define PDP_RDMA_S_POINTER_0_WORD_COUNT (0x1) +#define PDP_RDMA_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define PDP_RDMA_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define PDP_RDMA_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_RDMA_S_POINTER_0_PRODUCER_SHIFT)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_RANGE (0:0) +#define PDP_RDMA_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define PDP_RDMA_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define PDP_RDMA_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define PDP_RDMA_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define PDP_RDMA_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_RDMA_S_POINTER_0_CONSUMER_SHIFT)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_RANGE (16:16) +#define PDP_RDMA_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define PDP_RDMA_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define PDP_RDMA_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define PDP_RDMA_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register PDP_RDMA_D_OP_ENABLE_0 +#define PDP_RDMA_D_OP_ENABLE_0 (_MK_ADDR_CONST(0xc008)) +#define PDP_RDMA_D_OP_ENABLE_0_SECURE (0x0) +#define PDP_RDMA_D_OP_ENABLE_0_DUAL (0x0) +#define PDP_RDMA_D_OP_ENABLE_0_SCR (0) +#define PDP_RDMA_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0 +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0 (_MK_ADDR_CONST(0xc00c)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_SECURE (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_DUAL (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_SCR (0) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_RANGE (12:0) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_WOFFSET (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0 +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0 (_MK_ADDR_CONST(0xc010)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_SECURE (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_DUAL (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_SCR (0) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_RANGE (12:0) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_WOFFSET (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0 +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0 (_MK_ADDR_CONST(0xc014)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_SECURE (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_DUAL (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_SCR (0) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_RANGE (12:0) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_WOFFSET (0x0) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_FLYING_MODE_0 +#define PDP_RDMA_D_FLYING_MODE_0 (_MK_ADDR_CONST(0xc018)) +#define PDP_RDMA_D_FLYING_MODE_0_SECURE (0x0) +#define PDP_RDMA_D_FLYING_MODE_0_DUAL (0x0) +#define PDP_RDMA_D_FLYING_MODE_0_SCR (0) +#define PDP_RDMA_D_FLYING_MODE_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_FLYING_MODE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_FLYING_MODE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_FLYING_MODE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_FLYING_MODE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_FLYING_MODE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_FLYING_MODE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_SHIFT)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_RANGE (0:0) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_WOFFSET (0x0) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_ON_FLYING (_MK_ENUM_CONST(0)) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_OFF_FLYING (_MK_ENUM_CONST(1)) + + +// Register PDP_RDMA_D_SRC_BASE_ADDR_LOW_0 +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xc01c)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SECURE (0x0) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_DUAL (0x0) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SCR (0) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_RANGE (31:5) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_WOFFSET (0x0) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xc020)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SECURE (0x0) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_DUAL (0x0) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SCR (0) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_RANGE (31:0) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_WOFFSET (0x0) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_SRC_LINE_STRIDE_0 +#define PDP_RDMA_D_SRC_LINE_STRIDE_0 (_MK_ADDR_CONST(0xc024)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SECURE (0x0) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_DUAL (0x0) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SCR (0) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_RANGE (31:5) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_WOFFSET (0x0) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_SRC_SURFACE_STRIDE_0 +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xc028)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SECURE (0x0) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_DUAL (0x0) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SCR (0) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_RANGE (31:5) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_WOFFSET (0x0) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_SRC_RAM_CFG_0 +#define PDP_RDMA_D_SRC_RAM_CFG_0 (_MK_ADDR_CONST(0xc02c)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SECURE (0x0) +#define PDP_RDMA_D_SRC_RAM_CFG_0_DUAL (0x0) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SCR (0) +#define PDP_RDMA_D_SRC_RAM_CFG_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_SRC_RAM_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_SHIFT)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_RANGE (0:0) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_WOFFSET (0x0) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register PDP_RDMA_D_DATA_FORMAT_0 +#define PDP_RDMA_D_DATA_FORMAT_0 (_MK_ADDR_CONST(0xc030)) +#define PDP_RDMA_D_DATA_FORMAT_0_SECURE (0x0) +#define PDP_RDMA_D_DATA_FORMAT_0_DUAL (0x0) +#define PDP_RDMA_D_DATA_FORMAT_0_SCR (0) +#define PDP_RDMA_D_DATA_FORMAT_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_DATA_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define PDP_RDMA_D_DATA_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define PDP_RDMA_D_DATA_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FIELD \ + (_MK_FIELD_CONST(0x3, PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_RANGE (1:0) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_WOFFSET (0x0) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT8 (_MK_ENUM_CONST(0)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT16 (_MK_ENUM_CONST(1)) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FP16 (_MK_ENUM_CONST(2)) + + +// Register PDP_RDMA_D_OPERATION_MODE_CFG_0 +#define PDP_RDMA_D_OPERATION_MODE_CFG_0 (_MK_ADDR_CONST(0xc034)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SECURE (0x0) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_DUAL (0x0) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SCR (0) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_RESET_MASK (_MK_MASK_CONST(0xff)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_READ_MASK (_MK_MASK_CONST(0xff)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_WRITE_MASK (_MK_MASK_CONST(0xff)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_FIELD \ + (_MK_FIELD_CONST(0xff, \ + PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_RANGE (7:0) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_WOFFSET (0x0) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_POOLING_KERNEL_CFG_0 +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0 (_MK_ADDR_CONST(0xc038)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_SECURE (0x0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_DUAL (0x0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_SCR (0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_RESET_MASK (_MK_MASK_CONST(0xff)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_READ_MASK (_MK_MASK_CONST(0xff)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_WRITE_MASK (_MK_MASK_CONST(0xff)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_FIELD \ + (_MK_FIELD_CONST(0xf, \ + PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_RANGE (3:0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_WOFFSET (0x0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xf)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_1 \ + (_MK_ENUM_CONST(0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_2 \ + (_MK_ENUM_CONST(1)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_3 \ + (_MK_ENUM_CONST(2)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_4 \ + (_MK_ENUM_CONST(3)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_5 \ + (_MK_ENUM_CONST(4)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_6 \ + (_MK_ENUM_CONST(5)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_7 \ + (_MK_ENUM_CONST(6)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_8 \ + (_MK_ENUM_CONST(7)) + +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT \ + (_MK_SHIFT_CONST(4)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_FIELD \ + (_MK_FIELD_CONST(0xf, \ + PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_RANGE (7:4) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_WOFFSET (0x0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xf)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_POOLING_PADDING_CFG_0 +#define PDP_RDMA_D_POOLING_PADDING_CFG_0 (_MK_ADDR_CONST(0xc03c)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_SECURE (0x0) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_DUAL (0x0) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_SCR (0) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_RESET_MASK (_MK_MASK_CONST(0xf)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_READ_MASK (_MK_MASK_CONST(0xf)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_WRITE_MASK (_MK_MASK_CONST(0xf)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_FIELD \ + (_MK_FIELD_CONST(0xf, \ + PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_SHIFT)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_RANGE (3:0) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_WOFFSET (0x0) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xf)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_PARTIAL_WIDTH_IN_0 +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0 (_MK_ADDR_CONST(0xc040)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_SECURE (0x0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_DUAL (0x0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_SCR (0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_RESET_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_READ_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_WRITE_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_RANGE (9:0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_WOFFSET (0x0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT \ + (_MK_SHIFT_CONST(10)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_RANGE (19:10) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_WOFFSET (0x0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT \ + (_MK_SHIFT_CONST(20)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_RANGE (29:20) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_WOFFSET (0x0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_PERF_ENABLE_0 +#define PDP_RDMA_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0xc044)) +#define PDP_RDMA_D_PERF_ENABLE_0_SECURE (0x0) +#define PDP_RDMA_D_PERF_ENABLE_0_DUAL (0x0) +#define PDP_RDMA_D_PERF_ENABLE_0_SCR (0) +#define PDP_RDMA_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_RANGE (0:0) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_WOFFSET (0x0) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_INIT_ENUM (DISABLE) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DISABLE (_MK_ENUM_CONST(0)) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register PDP_RDMA_D_PERF_READ_STALL_0 +#define PDP_RDMA_D_PERF_READ_STALL_0 (_MK_ADDR_CONST(0xc048)) +#define PDP_RDMA_D_PERF_READ_STALL_0_SECURE (0x0) +#define PDP_RDMA_D_PERF_READ_STALL_0_DUAL (0x0) +#define PDP_RDMA_D_PERF_READ_STALL_0_SCR (0) +#define PDP_RDMA_D_PERF_READ_STALL_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_PERF_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_PERF_READ_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_PERF_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_RANGE (31:0) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_WOFFSET (0x0) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_RDMA_D_CYA_0 +#define PDP_RDMA_D_CYA_0 (_MK_ADDR_CONST(0xc04c)) +#define PDP_RDMA_D_CYA_0_SECURE (0x0) +#define PDP_RDMA_D_CYA_0_DUAL (0x0) +#define PDP_RDMA_D_CYA_0_SCR (0) +#define PDP_RDMA_D_CYA_0_WORD_COUNT (0x1) +#define PDP_RDMA_D_CYA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_CYA_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_CYA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_CYA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_CYA_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_CYA_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_CYA_0_CYA_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_RDMA_D_CYA_0_CYA_FIELD \ + (_MK_FIELD_CONST(0xffffffff, PDP_RDMA_D_CYA_0_CYA_SHIFT)) +#define PDP_RDMA_D_CYA_0_CYA_RANGE (31:0) +#define PDP_RDMA_D_CYA_0_CYA_WOFFSET (0x0) +#define PDP_RDMA_D_CYA_0_CYA_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_CYA_0_CYA_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_RDMA_D_CYA_0_CYA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_CYA_0_CYA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_CYA_0_CYA_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_RDMA_D_CYA_0_CYA_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register PDP_S_STATUS_0 +#define PDP_S_STATUS_0 (_MK_ADDR_CONST(0xd000)) +#define PDP_S_STATUS_0_SECURE (0x0) +#define PDP_S_STATUS_0_DUAL (0x0) +#define PDP_S_STATUS_0_SCR (0) +#define PDP_S_STATUS_0_WORD_COUNT (0x1) +#define PDP_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define PDP_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define PDP_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, PDP_S_STATUS_0_STATUS_0_SHIFT)) +#define PDP_S_STATUS_0_STATUS_0_RANGE (1:0) +#define PDP_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define PDP_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define PDP_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define PDP_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define PDP_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define PDP_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define PDP_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define PDP_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, PDP_S_STATUS_0_STATUS_1_SHIFT)) +#define PDP_S_STATUS_0_STATUS_1_RANGE (17:16) +#define PDP_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define PDP_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define PDP_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define PDP_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define PDP_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define PDP_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register PDP_S_POINTER_0 +#define PDP_S_POINTER_0 (_MK_ADDR_CONST(0xd004)) +#define PDP_S_POINTER_0_SECURE (0x0) +#define PDP_S_POINTER_0_DUAL (0x0) +#define PDP_S_POINTER_0_SCR (0) +#define PDP_S_POINTER_0_WORD_COUNT (0x1) +#define PDP_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define PDP_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define PDP_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_S_POINTER_0_PRODUCER_SHIFT)) +#define PDP_S_POINTER_0_PRODUCER_RANGE (0:0) +#define PDP_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define PDP_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define PDP_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define PDP_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define PDP_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define PDP_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_S_POINTER_0_CONSUMER_SHIFT)) +#define PDP_S_POINTER_0_CONSUMER_RANGE (16:16) +#define PDP_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define PDP_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define PDP_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define PDP_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register PDP_D_OP_ENABLE_0 +#define PDP_D_OP_ENABLE_0 (_MK_ADDR_CONST(0xd008)) +#define PDP_D_OP_ENABLE_0_SECURE (0x0) +#define PDP_D_OP_ENABLE_0_DUAL (0x0) +#define PDP_D_OP_ENABLE_0_SCR (0) +#define PDP_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define PDP_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define PDP_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define PDP_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define PDP_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define PDP_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define PDP_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register PDP_D_DATA_CUBE_IN_WIDTH_0 +#define PDP_D_DATA_CUBE_IN_WIDTH_0 (_MK_ADDR_CONST(0xd00c)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_SECURE (0x0) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_DUAL (0x0) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_SCR (0) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_WORD_COUNT (0x1) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_RANGE (12:0) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_WOFFSET (0x0) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DATA_CUBE_IN_HEIGHT_0 +#define PDP_D_DATA_CUBE_IN_HEIGHT_0 (_MK_ADDR_CONST(0xd010)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_SECURE (0x0) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_DUAL (0x0) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_SCR (0) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_WORD_COUNT (0x1) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_RANGE (12:0) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_WOFFSET (0x0) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DATA_CUBE_IN_CHANNEL_0 +#define PDP_D_DATA_CUBE_IN_CHANNEL_0 (_MK_ADDR_CONST(0xd014)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_SECURE (0x0) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_DUAL (0x0) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_SCR (0) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_WORD_COUNT (0x1) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_RANGE (12:0) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_WOFFSET (0x0) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DATA_CUBE_OUT_WIDTH_0 +#define PDP_D_DATA_CUBE_OUT_WIDTH_0 (_MK_ADDR_CONST(0xd018)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_SECURE (0x0) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_DUAL (0x0) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_SCR (0) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_WORD_COUNT (0x1) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_SHIFT)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_RANGE (12:0) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_WOFFSET (0x0) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DATA_CUBE_OUT_HEIGHT_0 +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0 (_MK_ADDR_CONST(0xd01c)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_SECURE (0x0) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_DUAL (0x0) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_SCR (0) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_WORD_COUNT (0x1) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_SHIFT)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_RANGE (12:0) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_WOFFSET (0x0) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DATA_CUBE_OUT_CHANNEL_0 +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0 (_MK_ADDR_CONST(0xd020)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_SECURE (0x0) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_DUAL (0x0) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_SCR (0) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_WORD_COUNT (0x1) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_SHIFT)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_RANGE (12:0) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_WOFFSET (0x0) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_OPERATION_MODE_CFG_0 +#define PDP_D_OPERATION_MODE_CFG_0 (_MK_ADDR_CONST(0xd024)) +#define PDP_D_OPERATION_MODE_CFG_0_SECURE (0x0) +#define PDP_D_OPERATION_MODE_CFG_0_DUAL (0x0) +#define PDP_D_OPERATION_MODE_CFG_0_SCR (0) +#define PDP_D_OPERATION_MODE_CFG_0_WORD_COUNT (0x1) +#define PDP_D_OPERATION_MODE_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_RESET_MASK (_MK_MASK_CONST(0xff13)) +#define PDP_D_OPERATION_MODE_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_READ_MASK (_MK_MASK_CONST(0xff13)) +#define PDP_D_OPERATION_MODE_CFG_0_WRITE_MASK (_MK_MASK_CONST(0xff13)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_FIELD \ + (_MK_FIELD_CONST(0x3, \ + PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_SHIFT)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_RANGE (1:0) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_WOFFSET (0x0) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_POOLING_METHOD_AVERAGE \ + (_MK_ENUM_CONST(0)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_POOLING_METHOD_MAX \ + (_MK_ENUM_CONST(1)) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_POOLING_METHOD_MIN \ + (_MK_ENUM_CONST(2)) + +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_SHIFT (_MK_SHIFT_CONST(4)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_SHIFT)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_RANGE (4:4) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_WOFFSET (0x0) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_ON_FLYING (_MK_ENUM_CONST(0)) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_OFF_FLYING (_MK_ENUM_CONST(1)) + +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT (_MK_SHIFT_CONST(8)) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_FIELD \ + (_MK_FIELD_CONST(0xff, PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT)) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_RANGE (15:8) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_WOFFSET (0x0) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_NAN_FLUSH_TO_ZERO_0 +#define PDP_D_NAN_FLUSH_TO_ZERO_0 (_MK_ADDR_CONST(0xd028)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_SECURE (0x0) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_DUAL (0x0) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_SCR (0) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_WORD_COUNT (0x1) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_RANGE (0:0) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_WOFFSET (0x0) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_INIT_ENUM (DISABLE) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DISABLE (_MK_ENUM_CONST(0)) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_ENABLE (_MK_ENUM_CONST(1)) + + +// Register PDP_D_PARTIAL_WIDTH_IN_0 +#define PDP_D_PARTIAL_WIDTH_IN_0 (_MK_ADDR_CONST(0xd02c)) +#define PDP_D_PARTIAL_WIDTH_IN_0_SECURE (0x0) +#define PDP_D_PARTIAL_WIDTH_IN_0_DUAL (0x0) +#define PDP_D_PARTIAL_WIDTH_IN_0_SCR (0) +#define PDP_D_PARTIAL_WIDTH_IN_0_WORD_COUNT (0x1) +#define PDP_D_PARTIAL_WIDTH_IN_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_RESET_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_D_PARTIAL_WIDTH_IN_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_READ_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_D_PARTIAL_WIDTH_IN_0_WRITE_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_RANGE (9:0) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_WOFFSET (0x0) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT \ + (_MK_SHIFT_CONST(10)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_RANGE (19:10) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_WOFFSET (0x0) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT \ + (_MK_SHIFT_CONST(20)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_RANGE (29:20) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_WOFFSET (0x0) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_PARTIAL_WIDTH_OUT_0 +#define PDP_D_PARTIAL_WIDTH_OUT_0 (_MK_ADDR_CONST(0xd030)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_SECURE (0x0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_DUAL (0x0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_SCR (0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_WORD_COUNT (0x1) +#define PDP_D_PARTIAL_WIDTH_OUT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_RESET_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_READ_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_WRITE_MASK (_MK_MASK_CONST(0x3fffffff)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_SHIFT)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_RANGE (9:0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_WOFFSET (0x0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_SHIFT \ + (_MK_SHIFT_CONST(10)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_SHIFT)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_RANGE (19:10) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_WOFFSET (0x0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_SHIFT \ + (_MK_SHIFT_CONST(20)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_FIELD \ + (_MK_FIELD_CONST(0x3ff, \ + PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_SHIFT)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_RANGE (29:20) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_WOFFSET (0x0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3ff)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_KERNEL_CFG_0 +#define PDP_D_POOLING_KERNEL_CFG_0 (_MK_ADDR_CONST(0xd034)) +#define PDP_D_POOLING_KERNEL_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_SCR (0) +#define PDP_D_POOLING_KERNEL_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_KERNEL_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_RESET_MASK (_MK_MASK_CONST(0xff0f0f)) +#define PDP_D_POOLING_KERNEL_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_READ_MASK (_MK_MASK_CONST(0xff0f0f)) +#define PDP_D_POOLING_KERNEL_CFG_0_WRITE_MASK (_MK_MASK_CONST(0xff0f0f)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_FIELD \ + (_MK_FIELD_CONST(0xf, PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_RANGE (3:0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_WOFFSET (0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xf)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_1 \ + (_MK_ENUM_CONST(0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_2 \ + (_MK_ENUM_CONST(1)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_3 \ + (_MK_ENUM_CONST(2)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_4 \ + (_MK_ENUM_CONST(3)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_5 \ + (_MK_ENUM_CONST(4)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_6 \ + (_MK_ENUM_CONST(5)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_7 \ + (_MK_ENUM_CONST(6)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_8 \ + (_MK_ENUM_CONST(7)) + +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_SHIFT (_MK_SHIFT_CONST(8)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0xf, \ + PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_SHIFT)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_RANGE (11:8) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_WOFFSET (0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xf)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_1 \ + (_MK_ENUM_CONST(0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_2 \ + (_MK_ENUM_CONST(1)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_3 \ + (_MK_ENUM_CONST(2)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_4 \ + (_MK_ENUM_CONST(3)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_5 \ + (_MK_ENUM_CONST(4)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_6 \ + (_MK_ENUM_CONST(5)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_7 \ + (_MK_ENUM_CONST(6)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_8 \ + (_MK_ENUM_CONST(7)) + +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_FIELD \ + (_MK_FIELD_CONST(0xf, \ + PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_RANGE (19:16) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_WOFFSET (0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xf)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_SHIFT \ + (_MK_SHIFT_CONST(20)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0xf, \ + PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_SHIFT)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_RANGE (23:20) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_WOFFSET (0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xf)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_RECIP_KERNEL_WIDTH_0 +#define PDP_D_RECIP_KERNEL_WIDTH_0 (_MK_ADDR_CONST(0xd038)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_SECURE (0x0) +#define PDP_D_RECIP_KERNEL_WIDTH_0_DUAL (0x0) +#define PDP_D_RECIP_KERNEL_WIDTH_0_SCR (0) +#define PDP_D_RECIP_KERNEL_WIDTH_0_WORD_COUNT (0x1) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RESET_MASK (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_READ_MASK (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_WRITE_MASK (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1ffff, \ + PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_SHIFT)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_RANGE (16:0) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_WOFFSET (0x0) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_RECIP_KERNEL_HEIGHT_0 +#define PDP_D_RECIP_KERNEL_HEIGHT_0 (_MK_ADDR_CONST(0xd03c)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_SECURE (0x0) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_DUAL (0x0) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_SCR (0) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_WORD_COUNT (0x1) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RESET_MASK (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_READ_MASK (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_WRITE_MASK (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1ffff, \ + PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_SHIFT)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_RANGE (16:0) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_WOFFSET (0x0) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1ffff)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_CFG_0 +#define PDP_D_POOLING_PADDING_CFG_0 (_MK_ADDR_CONST(0xd040)) +#define PDP_D_POOLING_PADDING_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_RESET_MASK (_MK_MASK_CONST(0x7777)) +#define PDP_D_POOLING_PADDING_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_READ_MASK (_MK_MASK_CONST(0x7777)) +#define PDP_D_POOLING_PADDING_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x7777)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_FIELD \ + (_MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_SHIFT)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_RANGE (2:0) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_SHIFT (_MK_SHIFT_CONST(4)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_FIELD \ + (_MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_SHIFT)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_RANGE (6:4) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_SHIFT (_MK_SHIFT_CONST(8)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_FIELD \ + (_MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_SHIFT)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_RANGE (10:8) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_SHIFT (_MK_SHIFT_CONST(12)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_FIELD \ + (_MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_SHIFT)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_RANGE (14:12) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_VALUE_1_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0 (_MK_ADDR_CONST(0xd044)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_RESET_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_READ_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_WRITE_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_FIELD \ + (_MK_FIELD_CONST(0x7ffff, \ + PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_SHIFT)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_RANGE (18:0) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_VALUE_2_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0 (_MK_ADDR_CONST(0xd048)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_RESET_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_READ_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_WRITE_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_FIELD \ + (_MK_FIELD_CONST(0x7ffff, \ + PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_SHIFT)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_RANGE (18:0) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_VALUE_3_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0 (_MK_ADDR_CONST(0xd04c)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_RESET_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_READ_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_WRITE_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_FIELD \ + (_MK_FIELD_CONST(0x7ffff, \ + PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_SHIFT)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_RANGE (18:0) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_VALUE_4_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0 (_MK_ADDR_CONST(0xd050)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_RESET_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_READ_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_WRITE_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_FIELD \ + (_MK_FIELD_CONST(0x7ffff, \ + PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_SHIFT)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_RANGE (18:0) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_VALUE_5_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0 (_MK_ADDR_CONST(0xd054)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_RESET_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_READ_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_WRITE_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_FIELD \ + (_MK_FIELD_CONST(0x7ffff, \ + PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_SHIFT)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_RANGE (18:0) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_VALUE_6_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0 (_MK_ADDR_CONST(0xd058)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_RESET_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_READ_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_WRITE_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_FIELD \ + (_MK_FIELD_CONST(0x7ffff, \ + PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_SHIFT)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_RANGE (18:0) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_POOLING_PADDING_VALUE_7_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0 (_MK_ADDR_CONST(0xd05c)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_SECURE (0x0) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_DUAL (0x0) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_SCR (0) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_WORD_COUNT (0x1) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_RESET_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_SW_DEFAULT_VAL \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_READ_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_WRITE_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_FIELD \ + (_MK_FIELD_CONST(0x7ffff, \ + PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_SHIFT)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_RANGE (18:0) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_WOFFSET (0x0) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffff)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_SRC_BASE_ADDR_LOW_0 +#define PDP_D_SRC_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xd060)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SECURE (0x0) +#define PDP_D_SRC_BASE_ADDR_LOW_0_DUAL (0x0) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SCR (0) +#define PDP_D_SRC_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define PDP_D_SRC_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_RANGE (31:5) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_WOFFSET (0x0) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_SRC_BASE_ADDR_HIGH_0 +#define PDP_D_SRC_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xd064)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SECURE (0x0) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_DUAL (0x0) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SCR (0) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_RANGE (31:0) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_WOFFSET (0x0) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_SRC_LINE_STRIDE_0 +#define PDP_D_SRC_LINE_STRIDE_0 (_MK_ADDR_CONST(0xd068)) +#define PDP_D_SRC_LINE_STRIDE_0_SECURE (0x0) +#define PDP_D_SRC_LINE_STRIDE_0_DUAL (0x0) +#define PDP_D_SRC_LINE_STRIDE_0_SCR (0) +#define PDP_D_SRC_LINE_STRIDE_0_WORD_COUNT (0x1) +#define PDP_D_SRC_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_RANGE (31:5) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_WOFFSET (0x0) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_SRC_SURFACE_STRIDE_0 +#define PDP_D_SRC_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xd06c)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SECURE (0x0) +#define PDP_D_SRC_SURFACE_STRIDE_0_DUAL (0x0) +#define PDP_D_SRC_SURFACE_STRIDE_0_SCR (0) +#define PDP_D_SRC_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define PDP_D_SRC_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_RANGE (31:5) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_WOFFSET (0x0) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DST_BASE_ADDR_LOW_0 +#define PDP_D_DST_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xd070)) +#define PDP_D_DST_BASE_ADDR_LOW_0_SECURE (0x0) +#define PDP_D_DST_BASE_ADDR_LOW_0_DUAL (0x0) +#define PDP_D_DST_BASE_ADDR_LOW_0_SCR (0) +#define PDP_D_DST_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define PDP_D_DST_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_RANGE (31:5) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_WOFFSET (0x0) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DST_BASE_ADDR_HIGH_0 +#define PDP_D_DST_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xd074)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_SECURE (0x0) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DUAL (0x0) +#define PDP_D_DST_BASE_ADDR_HIGH_0_SCR (0) +#define PDP_D_DST_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define PDP_D_DST_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_RANGE (31:0) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_WOFFSET (0x0) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DST_LINE_STRIDE_0 +#define PDP_D_DST_LINE_STRIDE_0 (_MK_ADDR_CONST(0xd078)) +#define PDP_D_DST_LINE_STRIDE_0_SECURE (0x0) +#define PDP_D_DST_LINE_STRIDE_0_DUAL (0x0) +#define PDP_D_DST_LINE_STRIDE_0_SCR (0) +#define PDP_D_DST_LINE_STRIDE_0_WORD_COUNT (0x1) +#define PDP_D_DST_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_RANGE (31:5) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_WOFFSET (0x0) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DST_SURFACE_STRIDE_0 +#define PDP_D_DST_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xd07c)) +#define PDP_D_DST_SURFACE_STRIDE_0_SECURE (0x0) +#define PDP_D_DST_SURFACE_STRIDE_0_DUAL (0x0) +#define PDP_D_DST_SURFACE_STRIDE_0_SCR (0) +#define PDP_D_DST_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define PDP_D_DST_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_SURFACE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_SURFACE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_SURFACE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_RANGE (31:5) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_WOFFSET (0x0) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_DST_RAM_CFG_0 +#define PDP_D_DST_RAM_CFG_0 (_MK_ADDR_CONST(0xd080)) +#define PDP_D_DST_RAM_CFG_0_SECURE (0x0) +#define PDP_D_DST_RAM_CFG_0_DUAL (0x0) +#define PDP_D_DST_RAM_CFG_0_SCR (0) +#define PDP_D_DST_RAM_CFG_0_WORD_COUNT (0x1) +#define PDP_D_DST_RAM_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_RAM_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_DST_RAM_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_RAM_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_RAM_CFG_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_DST_RAM_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_SHIFT)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_RANGE (0:0) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_WOFFSET (0x0) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register PDP_D_DATA_FORMAT_0 +#define PDP_D_DATA_FORMAT_0 (_MK_ADDR_CONST(0xd084)) +#define PDP_D_DATA_FORMAT_0_SECURE (0x0) +#define PDP_D_DATA_FORMAT_0_DUAL (0x0) +#define PDP_D_DATA_FORMAT_0_SCR (0) +#define PDP_D_DATA_FORMAT_0_WORD_COUNT (0x1) +#define PDP_D_DATA_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define PDP_D_DATA_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define PDP_D_DATA_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_FIELD \ + (_MK_FIELD_CONST(0x3, PDP_D_DATA_FORMAT_0_INPUT_DATA_SHIFT)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_RANGE (1:0) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_WOFFSET (0x0) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_INT8 (_MK_ENUM_CONST(0)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_INT16 (_MK_ENUM_CONST(1)) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_FP16 (_MK_ENUM_CONST(2)) + + +// Register PDP_D_INF_INPUT_NUM_0 +#define PDP_D_INF_INPUT_NUM_0 (_MK_ADDR_CONST(0xd088)) +#define PDP_D_INF_INPUT_NUM_0_SECURE (0x0) +#define PDP_D_INF_INPUT_NUM_0_DUAL (0x0) +#define PDP_D_INF_INPUT_NUM_0_SCR (0) +#define PDP_D_INF_INPUT_NUM_0_WORD_COUNT (0x1) +#define PDP_D_INF_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_INF_INPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_INF_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_RANGE (31:0) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_WOFFSET (0x0) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_NAN_INPUT_NUM_0 +#define PDP_D_NAN_INPUT_NUM_0 (_MK_ADDR_CONST(0xd08c)) +#define PDP_D_NAN_INPUT_NUM_0_SECURE (0x0) +#define PDP_D_NAN_INPUT_NUM_0_DUAL (0x0) +#define PDP_D_NAN_INPUT_NUM_0_SCR (0) +#define PDP_D_NAN_INPUT_NUM_0_WORD_COUNT (0x1) +#define PDP_D_NAN_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_NAN_INPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_NAN_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_RANGE (31:0) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_WOFFSET (0x0) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_NAN_OUTPUT_NUM_0 +#define PDP_D_NAN_OUTPUT_NUM_0 (_MK_ADDR_CONST(0xd090)) +#define PDP_D_NAN_OUTPUT_NUM_0_SECURE (0x0) +#define PDP_D_NAN_OUTPUT_NUM_0_DUAL (0x0) +#define PDP_D_NAN_OUTPUT_NUM_0_SCR (0) +#define PDP_D_NAN_OUTPUT_NUM_0_WORD_COUNT (0x1) +#define PDP_D_NAN_OUTPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_NAN_OUTPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_NAN_OUTPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_RANGE (31:0) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_WOFFSET (0x0) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_PERF_ENABLE_0 +#define PDP_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0xd094)) +#define PDP_D_PERF_ENABLE_0_SECURE (0x0) +#define PDP_D_PERF_ENABLE_0_DUAL (0x0) +#define PDP_D_PERF_ENABLE_0_SCR (0) +#define PDP_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define PDP_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_FIELD \ + (_MK_FIELD_CONST(0x1, PDP_D_PERF_ENABLE_0_DMA_EN_SHIFT)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_RANGE (0:0) +#define PDP_D_PERF_ENABLE_0_DMA_EN_WOFFSET (0x0) +#define PDP_D_PERF_ENABLE_0_DMA_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_INIT_ENUM (DISABLE) +#define PDP_D_PERF_ENABLE_0_DMA_EN_DISABLE (_MK_ENUM_CONST(0)) +#define PDP_D_PERF_ENABLE_0_DMA_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register PDP_D_PERF_WRITE_STALL_0 +#define PDP_D_PERF_WRITE_STALL_0 (_MK_ADDR_CONST(0xd098)) +#define PDP_D_PERF_WRITE_STALL_0_SECURE (0x0) +#define PDP_D_PERF_WRITE_STALL_0_DUAL (0x0) +#define PDP_D_PERF_WRITE_STALL_0_SCR (0) +#define PDP_D_PERF_WRITE_STALL_0_WORD_COUNT (0x1) +#define PDP_D_PERF_WRITE_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_PERF_WRITE_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_PERF_WRITE_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_RANGE (31:0) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_WOFFSET (0x0) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register PDP_D_CYA_0 +#define PDP_D_CYA_0 (_MK_ADDR_CONST(0xd09c)) +#define PDP_D_CYA_0_SECURE (0x0) +#define PDP_D_CYA_0_DUAL (0x0) +#define PDP_D_CYA_0_SCR (0) +#define PDP_D_CYA_0_WORD_COUNT (0x1) +#define PDP_D_CYA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_CYA_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_CYA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define PDP_D_CYA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_CYA_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_CYA_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_CYA_0_CYA_SHIFT (_MK_SHIFT_CONST(0)) +#define PDP_D_CYA_0_CYA_FIELD \ + (_MK_FIELD_CONST(0xffffffff, PDP_D_CYA_0_CYA_SHIFT)) +#define PDP_D_CYA_0_CYA_RANGE (31:0) +#define PDP_D_CYA_0_CYA_WOFFSET (0x0) +#define PDP_D_CYA_0_CYA_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_CYA_0_CYA_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define PDP_D_CYA_0_CYA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define PDP_D_CYA_0_CYA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define PDP_D_CYA_0_CYA_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define PDP_D_CYA_0_CYA_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_S_STATUS_0 +#define CDP_RDMA_S_STATUS_0 (_MK_ADDR_CONST(0xe000)) +#define CDP_RDMA_S_STATUS_0_SECURE (0x0) +#define CDP_RDMA_S_STATUS_0_DUAL (0x0) +#define CDP_RDMA_S_STATUS_0_SCR (0) +#define CDP_RDMA_S_STATUS_0_WORD_COUNT (0x1) +#define CDP_RDMA_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define CDP_RDMA_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define CDP_RDMA_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, CDP_RDMA_S_STATUS_0_STATUS_0_SHIFT)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_RANGE (1:0) +#define CDP_RDMA_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define CDP_RDMA_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define CDP_RDMA_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define CDP_RDMA_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define CDP_RDMA_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, CDP_RDMA_S_STATUS_0_STATUS_1_SHIFT)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_RANGE (17:16) +#define CDP_RDMA_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define CDP_RDMA_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define CDP_RDMA_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define CDP_RDMA_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register CDP_RDMA_S_POINTER_0 +#define CDP_RDMA_S_POINTER_0 (_MK_ADDR_CONST(0xe004)) +#define CDP_RDMA_S_POINTER_0_SECURE (0x0) +#define CDP_RDMA_S_POINTER_0_DUAL (0x0) +#define CDP_RDMA_S_POINTER_0_SCR (0) +#define CDP_RDMA_S_POINTER_0_WORD_COUNT (0x1) +#define CDP_RDMA_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CDP_RDMA_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CDP_RDMA_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_RDMA_S_POINTER_0_PRODUCER_SHIFT)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_RANGE (0:0) +#define CDP_RDMA_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define CDP_RDMA_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define CDP_RDMA_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CDP_RDMA_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define CDP_RDMA_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_RDMA_S_POINTER_0_CONSUMER_SHIFT)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_RANGE (16:16) +#define CDP_RDMA_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define CDP_RDMA_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define CDP_RDMA_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CDP_RDMA_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register CDP_RDMA_D_OP_ENABLE_0 +#define CDP_RDMA_D_OP_ENABLE_0 (_MK_ADDR_CONST(0xe008)) +#define CDP_RDMA_D_OP_ENABLE_0_SECURE (0x0) +#define CDP_RDMA_D_OP_ENABLE_0_DUAL (0x0) +#define CDP_RDMA_D_OP_ENABLE_0_SCR (0) +#define CDP_RDMA_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDP_RDMA_D_DATA_CUBE_WIDTH_0 +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0 (_MK_ADDR_CONST(0xe00c)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_SECURE (0x0) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_DUAL (0x0) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_SCR (0) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_RANGE (12:0) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_WOFFSET (0x0) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_DATA_CUBE_HEIGHT_0 +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0 (_MK_ADDR_CONST(0xe010)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_SECURE (0x0) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_DUAL (0x0) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_SCR (0) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_RANGE (12:0) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_WOFFSET (0x0) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_DATA_CUBE_CHANNEL_0 +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0 (_MK_ADDR_CONST(0xe014)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_SECURE (0x0) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_DUAL (0x0) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_SCR (0) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_RANGE (12:0) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_WOFFSET (0x0) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_SRC_BASE_ADDR_LOW_0 +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xe018)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SECURE (0x0) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_DUAL (0x0) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SCR (0) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_RANGE (31:5) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_WOFFSET (0x0) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xe01c)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SECURE (0x0) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_DUAL (0x0) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SCR (0) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_RANGE (31:0) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_WOFFSET (0x0) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_SRC_LINE_STRIDE_0 +#define CDP_RDMA_D_SRC_LINE_STRIDE_0 (_MK_ADDR_CONST(0xe020)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SECURE (0x0) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_DUAL (0x0) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SCR (0) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_RANGE (31:5) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_WOFFSET (0x0) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_SRC_SURFACE_STRIDE_0 +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xe024)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SECURE (0x0) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_DUAL (0x0) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SCR (0) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_RESET_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_READ_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_WRITE_MASK \ + (_MK_MASK_CONST(0xffffffe0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_RANGE (31:5) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_WOFFSET (0x0) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_SRC_DMA_CFG_0 +#define CDP_RDMA_D_SRC_DMA_CFG_0 (_MK_ADDR_CONST(0xe028)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SECURE (0x0) +#define CDP_RDMA_D_SRC_DMA_CFG_0_DUAL (0x0) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SCR (0) +#define CDP_RDMA_D_SRC_DMA_CFG_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_SRC_DMA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_RANGE (0:0) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_WOFFSET (0x0) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register CDP_RDMA_D_SRC_COMPRESSION_EN_0 +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0 (_MK_ADDR_CONST(0xe02c)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SECURE (0x0) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_DUAL (0x0) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SCR (0) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_FIELD \ + (_MK_FIELD_CONST(0x1, \ + CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_SHIFT)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_RANGE (0:0) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_WOFFSET (0x0) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_DISABLE \ + (_MK_ENUM_CONST(0)) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_ENABLE \ + (_MK_ENUM_CONST(1)) + + +// Register CDP_RDMA_D_OPERATION_MODE_0 +#define CDP_RDMA_D_OPERATION_MODE_0 (_MK_ADDR_CONST(0xe030)) +#define CDP_RDMA_D_OPERATION_MODE_0_SECURE (0x0) +#define CDP_RDMA_D_OPERATION_MODE_0_DUAL (0x0) +#define CDP_RDMA_D_OPERATION_MODE_0_SCR (0) +#define CDP_RDMA_D_OPERATION_MODE_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_OPERATION_MODE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_D_OPERATION_MODE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_D_OPERATION_MODE_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_FIELD \ + (_MK_FIELD_CONST(0x3, \ + CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_SHIFT)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_RANGE (1:0) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_WOFFSET (0x0) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_READPHILE \ + (_MK_ENUM_CONST(0)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_WRITEPHILE \ + (_MK_ENUM_CONST(1)) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_ORDINARY \ + (_MK_ENUM_CONST(2)) + + +// Register CDP_RDMA_D_DATA_FORMAT_0 +#define CDP_RDMA_D_DATA_FORMAT_0 (_MK_ADDR_CONST(0xe034)) +#define CDP_RDMA_D_DATA_FORMAT_0_SECURE (0x0) +#define CDP_RDMA_D_DATA_FORMAT_0_DUAL (0x0) +#define CDP_RDMA_D_DATA_FORMAT_0_SCR (0) +#define CDP_RDMA_D_DATA_FORMAT_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_DATA_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_D_DATA_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_D_DATA_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FIELD \ + (_MK_FIELD_CONST(0x3, CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_RANGE (1:0) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_WOFFSET (0x0) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT8 (_MK_ENUM_CONST(0)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT16 (_MK_ENUM_CONST(1)) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FP16 (_MK_ENUM_CONST(2)) + + +// Register CDP_RDMA_D_PERF_ENABLE_0 +#define CDP_RDMA_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0xe038)) +#define CDP_RDMA_D_PERF_ENABLE_0_SECURE (0x0) +#define CDP_RDMA_D_PERF_ENABLE_0_DUAL (0x0) +#define CDP_RDMA_D_PERF_ENABLE_0_SCR (0) +#define CDP_RDMA_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_RANGE (0:0) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_WOFFSET (0x0) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_INIT_ENUM (DISABLE) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDP_RDMA_D_PERF_READ_STALL_0 +#define CDP_RDMA_D_PERF_READ_STALL_0 (_MK_ADDR_CONST(0xe03c)) +#define CDP_RDMA_D_PERF_READ_STALL_0_SECURE (0x0) +#define CDP_RDMA_D_PERF_READ_STALL_0_DUAL (0x0) +#define CDP_RDMA_D_PERF_READ_STALL_0_SCR (0) +#define CDP_RDMA_D_PERF_READ_STALL_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_PERF_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_PERF_READ_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_PERF_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_RANGE (31:0) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_WOFFSET (0x0) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_RDMA_D_CYA_0 +#define CDP_RDMA_D_CYA_0 (_MK_ADDR_CONST(0xe040)) +#define CDP_RDMA_D_CYA_0_SECURE (0x0) +#define CDP_RDMA_D_CYA_0_DUAL (0x0) +#define CDP_RDMA_D_CYA_0_SCR (0) +#define CDP_RDMA_D_CYA_0_WORD_COUNT (0x1) +#define CDP_RDMA_D_CYA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_CYA_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_CYA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_CYA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_CYA_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_CYA_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_CYA_0_CYA_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_RDMA_D_CYA_0_CYA_FIELD \ + (_MK_FIELD_CONST(0xffffffff, CDP_RDMA_D_CYA_0_CYA_SHIFT)) +#define CDP_RDMA_D_CYA_0_CYA_RANGE (31:0) +#define CDP_RDMA_D_CYA_0_CYA_WOFFSET (0x0) +#define CDP_RDMA_D_CYA_0_CYA_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_CYA_0_CYA_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_RDMA_D_CYA_0_CYA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_CYA_0_CYA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_CYA_0_CYA_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_RDMA_D_CYA_0_CYA_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_STATUS_0 +#define CDP_S_STATUS_0 (_MK_ADDR_CONST(0xf000)) +#define CDP_S_STATUS_0_SECURE (0x0) +#define CDP_S_STATUS_0_DUAL (0x0) +#define CDP_S_STATUS_0_SCR (0) +#define CDP_S_STATUS_0_WORD_COUNT (0x1) +#define CDP_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define CDP_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define CDP_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, CDP_S_STATUS_0_STATUS_0_SHIFT)) +#define CDP_S_STATUS_0_STATUS_0_RANGE (1:0) +#define CDP_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define CDP_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDP_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define CDP_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define CDP_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define CDP_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define CDP_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define CDP_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, CDP_S_STATUS_0_STATUS_1_SHIFT)) +#define CDP_S_STATUS_0_STATUS_1_RANGE (17:16) +#define CDP_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define CDP_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDP_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define CDP_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define CDP_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define CDP_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register CDP_S_POINTER_0 +#define CDP_S_POINTER_0 (_MK_ADDR_CONST(0xf004)) +#define CDP_S_POINTER_0_SECURE (0x0) +#define CDP_S_POINTER_0_DUAL (0x0) +#define CDP_S_POINTER_0_SCR (0) +#define CDP_S_POINTER_0_WORD_COUNT (0x1) +#define CDP_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define CDP_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define CDP_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_POINTER_0_PRODUCER_SHIFT)) +#define CDP_S_POINTER_0_PRODUCER_RANGE (0:0) +#define CDP_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define CDP_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define CDP_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CDP_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define CDP_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define CDP_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_POINTER_0_CONSUMER_SHIFT)) +#define CDP_S_POINTER_0_CONSUMER_RANGE (16:16) +#define CDP_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define CDP_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define CDP_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define CDP_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register CDP_S_LUT_ACCESS_CFG_0 +#define CDP_S_LUT_ACCESS_CFG_0 (_MK_ADDR_CONST(0xf008)) +#define CDP_S_LUT_ACCESS_CFG_0_SECURE (0x0) +#define CDP_S_LUT_ACCESS_CFG_0_DUAL (0x0) +#define CDP_S_LUT_ACCESS_CFG_0_SCR (0) +#define CDP_S_LUT_ACCESS_CFG_0_WORD_COUNT (0x1) +#define CDP_S_LUT_ACCESS_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_RESET_MASK (_MK_MASK_CONST(0x303ff)) +#define CDP_S_LUT_ACCESS_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_READ_MASK (_MK_MASK_CONST(0x303ff)) +#define CDP_S_LUT_ACCESS_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x303ff)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_FIELD \ + (_MK_FIELD_CONST(0x3ff, CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_RANGE (9:0) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_WOFFSET (0x0) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_DEFAULT_MASK (_MK_MASK_CONST(0x3ff)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT (_MK_SHIFT_CONST(16)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_RANGE (16:16) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_WOFFSET (0x0) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LE (_MK_ENUM_CONST(0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LO (_MK_ENUM_CONST(1)) + +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT (_MK_SHIFT_CONST(17)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_RANGE (17:17) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_WOFFSET (0x0) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_READ (_MK_ENUM_CONST(0)) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_WRITE (_MK_ENUM_CONST(1)) + + +// Register CDP_S_LUT_ACCESS_DATA_0 +#define CDP_S_LUT_ACCESS_DATA_0 (_MK_ADDR_CONST(0xf00c)) +#define CDP_S_LUT_ACCESS_DATA_0_SECURE (0x0) +#define CDP_S_LUT_ACCESS_DATA_0_DUAL (0x0) +#define CDP_S_LUT_ACCESS_DATA_0_SCR (0) +#define CDP_S_LUT_ACCESS_DATA_0_WORD_COUNT (0x1) +#define CDP_S_LUT_ACCESS_DATA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_DATA_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_ACCESS_DATA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_DATA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_DATA_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_ACCESS_DATA_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_FIELD \ + (_MK_FIELD_CONST(0xffff, CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_RANGE (15:0) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_WOFFSET (0x0) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_CFG_0 +#define CDP_S_LUT_CFG_0 (_MK_ADDR_CONST(0xf010)) +#define CDP_S_LUT_CFG_0_SECURE (0x0) +#define CDP_S_LUT_CFG_0_DUAL (0x0) +#define CDP_S_LUT_CFG_0_SCR (0) +#define CDP_S_LUT_CFG_0_WORD_COUNT (0x1) +#define CDP_S_LUT_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_RESET_MASK (_MK_MASK_CONST(0x71)) +#define CDP_S_LUT_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_READ_MASK (_MK_MASK_CONST(0x71)) +#define CDP_S_LUT_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x71)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_RANGE (0:0) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_WOFFSET (0x0) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_EXPONENT (_MK_ENUM_CONST(0)) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_LINEAR (_MK_ENUM_CONST(1)) + +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT (_MK_SHIFT_CONST(4)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_RANGE (4:4) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_WOFFSET (0x0) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LE (_MK_ENUM_CONST(0)) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LO (_MK_ENUM_CONST(1)) + +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT (_MK_SHIFT_CONST(5)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_RANGE (5:5) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_WOFFSET (0x0) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LE (_MK_ENUM_CONST(0)) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LO (_MK_ENUM_CONST(1)) + +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT (_MK_SHIFT_CONST(6)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_RANGE (6:6) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_WOFFSET (0x0) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LE (_MK_ENUM_CONST(0)) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LO (_MK_ENUM_CONST(1)) + + +// Register CDP_S_LUT_INFO_0 +#define CDP_S_LUT_INFO_0 (_MK_ADDR_CONST(0xf014)) +#define CDP_S_LUT_INFO_0_SECURE (0x0) +#define CDP_S_LUT_INFO_0_DUAL (0x0) +#define CDP_S_LUT_INFO_0_SCR (0) +#define CDP_S_LUT_INFO_0_WORD_COUNT (0x1) +#define CDP_S_LUT_INFO_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_RESET_MASK (_MK_MASK_CONST(0xffffff)) +#define CDP_S_LUT_INFO_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_READ_MASK (_MK_MASK_CONST(0xffffff)) +#define CDP_S_LUT_INFO_0_WRITE_MASK (_MK_MASK_CONST(0xffffff)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xff, CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_RANGE (7:0) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_WOFFSET (0x0) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT (_MK_SHIFT_CONST(8)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_FIELD \ + (_MK_FIELD_CONST(0xff, CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_RANGE (15:8) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_WOFFSET (0x0) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT (_MK_SHIFT_CONST(16)) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_FIELD \ + (_MK_FIELD_CONST(0xff, CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT)) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_RANGE (23:16) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_WOFFSET (0x0) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xff)) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LE_START_LOW_0 +#define CDP_S_LUT_LE_START_LOW_0 (_MK_ADDR_CONST(0xf018)) +#define CDP_S_LUT_LE_START_LOW_0_SECURE (0x0) +#define CDP_S_LUT_LE_START_LOW_0_DUAL (0x0) +#define CDP_S_LUT_LE_START_LOW_0_SCR (0) +#define CDP_S_LUT_LE_START_LOW_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LE_START_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_START_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_START_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_SHIFT)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_RANGE (31:0) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_WOFFSET (0x0) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LE_START_HIGH_0 +#define CDP_S_LUT_LE_START_HIGH_0 (_MK_ADDR_CONST(0xf01c)) +#define CDP_S_LUT_LE_START_HIGH_0_SECURE (0x0) +#define CDP_S_LUT_LE_START_HIGH_0_DUAL (0x0) +#define CDP_S_LUT_LE_START_HIGH_0_SCR (0) +#define CDP_S_LUT_LE_START_HIGH_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LE_START_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_HIGH_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_START_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_HIGH_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_START_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_SHIFT)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_RANGE (5:0) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_WOFFSET (0x0) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LE_END_LOW_0 +#define CDP_S_LUT_LE_END_LOW_0 (_MK_ADDR_CONST(0xf020)) +#define CDP_S_LUT_LE_END_LOW_0_SECURE (0x0) +#define CDP_S_LUT_LE_END_LOW_0_DUAL (0x0) +#define CDP_S_LUT_LE_END_LOW_0_SCR (0) +#define CDP_S_LUT_LE_END_LOW_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LE_END_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_END_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_END_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_SHIFT)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_RANGE (31:0) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_WOFFSET (0x0) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LE_END_HIGH_0 +#define CDP_S_LUT_LE_END_HIGH_0 (_MK_ADDR_CONST(0xf024)) +#define CDP_S_LUT_LE_END_HIGH_0_SECURE (0x0) +#define CDP_S_LUT_LE_END_HIGH_0_DUAL (0x0) +#define CDP_S_LUT_LE_END_HIGH_0_SCR (0) +#define CDP_S_LUT_LE_END_HIGH_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LE_END_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_HIGH_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_END_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_HIGH_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_END_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_SHIFT)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_RANGE (5:0) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_WOFFSET (0x0) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LO_START_LOW_0 +#define CDP_S_LUT_LO_START_LOW_0 (_MK_ADDR_CONST(0xf028)) +#define CDP_S_LUT_LO_START_LOW_0_SECURE (0x0) +#define CDP_S_LUT_LO_START_LOW_0_DUAL (0x0) +#define CDP_S_LUT_LO_START_LOW_0_SCR (0) +#define CDP_S_LUT_LO_START_LOW_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LO_START_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_START_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_START_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_SHIFT)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_RANGE (31:0) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_WOFFSET (0x0) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LO_START_HIGH_0 +#define CDP_S_LUT_LO_START_HIGH_0 (_MK_ADDR_CONST(0xf02c)) +#define CDP_S_LUT_LO_START_HIGH_0_SECURE (0x0) +#define CDP_S_LUT_LO_START_HIGH_0_DUAL (0x0) +#define CDP_S_LUT_LO_START_HIGH_0_SCR (0) +#define CDP_S_LUT_LO_START_HIGH_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LO_START_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_HIGH_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_START_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_HIGH_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_START_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_SHIFT)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_RANGE (5:0) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_WOFFSET (0x0) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LO_END_LOW_0 +#define CDP_S_LUT_LO_END_LOW_0 (_MK_ADDR_CONST(0xf030)) +#define CDP_S_LUT_LO_END_LOW_0_SECURE (0x0) +#define CDP_S_LUT_LO_END_LOW_0_DUAL (0x0) +#define CDP_S_LUT_LO_END_LOW_0_SCR (0) +#define CDP_S_LUT_LO_END_LOW_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LO_END_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_END_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_END_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_SHIFT)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_RANGE (31:0) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_WOFFSET (0x0) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LO_END_HIGH_0 +#define CDP_S_LUT_LO_END_HIGH_0 (_MK_ADDR_CONST(0xf034)) +#define CDP_S_LUT_LO_END_HIGH_0_SECURE (0x0) +#define CDP_S_LUT_LO_END_HIGH_0_DUAL (0x0) +#define CDP_S_LUT_LO_END_HIGH_0_SCR (0) +#define CDP_S_LUT_LO_END_HIGH_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LO_END_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_HIGH_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_END_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_HIGH_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_END_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_FIELD \ + (_MK_FIELD_CONST(0x3f, \ + CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_SHIFT)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_RANGE (5:0) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_WOFFSET (0x0) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LE_SLOPE_SCALE_0 +#define CDP_S_LUT_LE_SLOPE_SCALE_0 (_MK_ADDR_CONST(0xf038)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_SECURE (0x0) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_DUAL (0x0) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_SCR (0) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_RANGE (15:0) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_WOFFSET (0x0) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_RANGE (31:16) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_WOFFSET (0x0) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LE_SLOPE_SHIFT_0 +#define CDP_S_LUT_LE_SLOPE_SHIFT_0 (_MK_ADDR_CONST(0xf03c)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_SECURE (0x0) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_DUAL (0x0) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_SCR (0) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_RESET_MASK (_MK_MASK_CONST(0x3ff)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_READ_MASK (_MK_MASK_CONST(0x3ff)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_WRITE_MASK (_MK_MASK_CONST(0x3ff)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_RANGE (4:0) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_WOFFSET (0x0) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_RANGE (9:5) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_WOFFSET (0x0) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LO_SLOPE_SCALE_0 +#define CDP_S_LUT_LO_SLOPE_SCALE_0 (_MK_ADDR_CONST(0xf040)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_SECURE (0x0) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_DUAL (0x0) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_SCR (0) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_RANGE (15:0) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_WOFFSET (0x0) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT \ + (_MK_SHIFT_CONST(16)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, \ + CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_RANGE (31:16) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_WOFFSET (0x0) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_S_LUT_LO_SLOPE_SHIFT_0 +#define CDP_S_LUT_LO_SLOPE_SHIFT_0 (_MK_ADDR_CONST(0xf044)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_SECURE (0x0) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_DUAL (0x0) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_SCR (0) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_WORD_COUNT (0x1) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_RESET_MASK (_MK_MASK_CONST(0x3ff)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_READ_MASK (_MK_MASK_CONST(0x3ff)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_WRITE_MASK (_MK_MASK_CONST(0x3ff)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_RANGE (4:0) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_WOFFSET (0x0) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_FIELD \ + (_MK_FIELD_CONST(0x1f, \ + CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_RANGE (9:5) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_WOFFSET (0x0) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_OP_ENABLE_0 +#define CDP_D_OP_ENABLE_0 (_MK_ADDR_CONST(0xf048)) +#define CDP_D_OP_ENABLE_0_SECURE (0x0) +#define CDP_D_OP_ENABLE_0_DUAL (0x0) +#define CDP_D_OP_ENABLE_0_SCR (0) +#define CDP_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define CDP_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define CDP_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define CDP_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define CDP_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define CDP_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDP_D_FUNC_BYPASS_0 +#define CDP_D_FUNC_BYPASS_0 (_MK_ADDR_CONST(0xf04c)) +#define CDP_D_FUNC_BYPASS_0_SECURE (0x0) +#define CDP_D_FUNC_BYPASS_0_DUAL (0x0) +#define CDP_D_FUNC_BYPASS_0_SCR (0) +#define CDP_D_FUNC_BYPASS_0_WORD_COUNT (0x1) +#define CDP_D_FUNC_BYPASS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_FUNC_BYPASS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_FUNC_BYPASS_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_SHIFT)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_RANGE (0:0) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_WOFFSET (0x0) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_INIT_ENUM (DISABLE) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_ENABLE (_MK_ENUM_CONST(1)) + +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_SHIFT (_MK_SHIFT_CONST(1)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_D_FUNC_BYPASS_0_MUL_BYPASS_SHIFT)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_RANGE (1:1) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_WOFFSET (0x0) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_INIT_ENUM (DISABLE) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDP_D_DST_BASE_ADDR_LOW_0 +#define CDP_D_DST_BASE_ADDR_LOW_0 (_MK_ADDR_CONST(0xf050)) +#define CDP_D_DST_BASE_ADDR_LOW_0_SECURE (0x0) +#define CDP_D_DST_BASE_ADDR_LOW_0_DUAL (0x0) +#define CDP_D_DST_BASE_ADDR_LOW_0_SCR (0) +#define CDP_D_DST_BASE_ADDR_LOW_0_WORD_COUNT (0x1) +#define CDP_D_DST_BASE_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_RANGE (31:5) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_WOFFSET (0x0) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DST_BASE_ADDR_HIGH_0 +#define CDP_D_DST_BASE_ADDR_HIGH_0 (_MK_ADDR_CONST(0xf054)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_SECURE (0x0) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DUAL (0x0) +#define CDP_D_DST_BASE_ADDR_HIGH_0_SCR (0) +#define CDP_D_DST_BASE_ADDR_HIGH_0_WORD_COUNT (0x1) +#define CDP_D_DST_BASE_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_RANGE (31:0) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_WOFFSET (0x0) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DST_LINE_STRIDE_0 +#define CDP_D_DST_LINE_STRIDE_0 (_MK_ADDR_CONST(0xf058)) +#define CDP_D_DST_LINE_STRIDE_0_SECURE (0x0) +#define CDP_D_DST_LINE_STRIDE_0_DUAL (0x0) +#define CDP_D_DST_LINE_STRIDE_0_SCR (0) +#define CDP_D_DST_LINE_STRIDE_0_WORD_COUNT (0x1) +#define CDP_D_DST_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_RANGE (31:5) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_WOFFSET (0x0) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DST_SURFACE_STRIDE_0 +#define CDP_D_DST_SURFACE_STRIDE_0 (_MK_ADDR_CONST(0xf05c)) +#define CDP_D_DST_SURFACE_STRIDE_0_SECURE (0x0) +#define CDP_D_DST_SURFACE_STRIDE_0_DUAL (0x0) +#define CDP_D_DST_SURFACE_STRIDE_0_SCR (0) +#define CDP_D_DST_SURFACE_STRIDE_0_WORD_COUNT (0x1) +#define CDP_D_DST_SURFACE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_SURFACE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_SURFACE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_SURFACE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_SURFACE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_SURFACE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_RANGE (31:5) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_WOFFSET (0x0) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DST_DMA_CFG_0 +#define CDP_D_DST_DMA_CFG_0 (_MK_ADDR_CONST(0xf060)) +#define CDP_D_DST_DMA_CFG_0_SECURE (0x0) +#define CDP_D_DST_DMA_CFG_0_DUAL (0x0) +#define CDP_D_DST_DMA_CFG_0_SCR (0) +#define CDP_D_DST_DMA_CFG_0_WORD_COUNT (0x1) +#define CDP_D_DST_DMA_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_DMA_CFG_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_DMA_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_DMA_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_DMA_CFG_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_DMA_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_RANGE (0:0) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_WOFFSET (0x0) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_CV (_MK_ENUM_CONST(0)) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_MC (_MK_ENUM_CONST(1)) + + +// Register CDP_D_DST_COMPRESSION_EN_0 +#define CDP_D_DST_COMPRESSION_EN_0 (_MK_ADDR_CONST(0xf064)) +#define CDP_D_DST_COMPRESSION_EN_0_SECURE (0x0) +#define CDP_D_DST_COMPRESSION_EN_0_DUAL (0x0) +#define CDP_D_DST_COMPRESSION_EN_0_SCR (0) +#define CDP_D_DST_COMPRESSION_EN_0_WORD_COUNT (0x1) +#define CDP_D_DST_COMPRESSION_EN_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_COMPRESSION_EN_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_COMPRESSION_EN_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_SHIFT \ + (_MK_SHIFT_CONST(0)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_FIELD \ + (_MK_FIELD_CONST(0x1, \ + CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_SHIFT)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_RANGE (0:0) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_WOFFSET (0x0) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_DISABLE \ + (_MK_ENUM_CONST(0)) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_ENABLE \ + (_MK_ENUM_CONST(1)) + + +// Register CDP_D_DATA_FORMAT_0 +#define CDP_D_DATA_FORMAT_0 (_MK_ADDR_CONST(0xf068)) +#define CDP_D_DATA_FORMAT_0_SECURE (0x0) +#define CDP_D_DATA_FORMAT_0_DUAL (0x0) +#define CDP_D_DATA_FORMAT_0_SCR (0) +#define CDP_D_DATA_FORMAT_0_WORD_COUNT (0x1) +#define CDP_D_DATA_FORMAT_0_RESET_VAL (_MK_MASK_CONST(0x1)) +#define CDP_D_DATA_FORMAT_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_DATA_FORMAT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATA_FORMAT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATA_FORMAT_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_DATA_FORMAT_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_FIELD \ + (_MK_FIELD_CONST(0x3, CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_SHIFT)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_RANGE (1:0) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_WOFFSET (0x0) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_DEFAULT (_MK_MASK_CONST(0x1)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_INT8 (_MK_ENUM_CONST(0)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_INT16 (_MK_ENUM_CONST(1)) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_FP16 (_MK_ENUM_CONST(2)) + + +// Register CDP_D_NAN_FLUSH_TO_ZERO_0 +#define CDP_D_NAN_FLUSH_TO_ZERO_0 (_MK_ADDR_CONST(0xf06c)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_SECURE (0x0) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_DUAL (0x0) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_SCR (0) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_WORD_COUNT (0x1) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_RANGE (0:0) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_WOFFSET (0x0) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_INIT_ENUM (DISABLE) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDP_D_LRN_CFG_0 +#define CDP_D_LRN_CFG_0 (_MK_ADDR_CONST(0xf070)) +#define CDP_D_LRN_CFG_0_SECURE (0x0) +#define CDP_D_LRN_CFG_0_DUAL (0x0) +#define CDP_D_LRN_CFG_0_SCR (0) +#define CDP_D_LRN_CFG_0_WORD_COUNT (0x1) +#define CDP_D_LRN_CFG_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_LRN_CFG_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_LRN_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_LRN_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_LRN_CFG_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_LRN_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_FIELD \ + (_MK_FIELD_CONST(0x3, CDP_D_LRN_CFG_0_NORMALZ_LEN_SHIFT)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_RANGE (1:0) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_WOFFSET (0x0) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN3 (_MK_ENUM_CONST(0)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN5 (_MK_ENUM_CONST(1)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN7 (_MK_ENUM_CONST(2)) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN9 (_MK_ENUM_CONST(3)) + + +// Register CDP_D_DATIN_OFFSET_0 +#define CDP_D_DATIN_OFFSET_0 (_MK_ADDR_CONST(0xf074)) +#define CDP_D_DATIN_OFFSET_0_SECURE (0x0) +#define CDP_D_DATIN_OFFSET_0_DUAL (0x0) +#define CDP_D_DATIN_OFFSET_0_SCR (0) +#define CDP_D_DATIN_OFFSET_0_WORD_COUNT (0x1) +#define CDP_D_DATIN_OFFSET_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_OFFSET_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_OFFSET_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_OFFSET_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_OFFSET_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_OFFSET_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xffff, CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_SHIFT)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_RANGE (15:0) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_WOFFSET (0x0) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DATIN_SCALE_0 +#define CDP_D_DATIN_SCALE_0 (_MK_ADDR_CONST(0xf078)) +#define CDP_D_DATIN_SCALE_0_SECURE (0x0) +#define CDP_D_DATIN_SCALE_0_DUAL (0x0) +#define CDP_D_DATIN_SCALE_0_SCR (0) +#define CDP_D_DATIN_SCALE_0_WORD_COUNT (0x1) +#define CDP_D_DATIN_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x1)) +#define CDP_D_DATIN_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, CDP_D_DATIN_SCALE_0_DATIN_SCALE_SHIFT)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_RANGE (15:0) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_WOFFSET (0x0) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_DEFAULT (_MK_MASK_CONST(0x1)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_DEFAULT_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DATIN_SHIFTER_0 +#define CDP_D_DATIN_SHIFTER_0 (_MK_ADDR_CONST(0xf07c)) +#define CDP_D_DATIN_SHIFTER_0_SECURE (0x0) +#define CDP_D_DATIN_SHIFTER_0_DUAL (0x0) +#define CDP_D_DATIN_SHIFTER_0_SCR (0) +#define CDP_D_DATIN_SHIFTER_0_WORD_COUNT (0x1) +#define CDP_D_DATIN_SHIFTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SHIFTER_0_RESET_MASK (_MK_MASK_CONST(0x1f)) +#define CDP_D_DATIN_SHIFTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SHIFTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SHIFTER_0_READ_MASK (_MK_MASK_CONST(0x1f)) +#define CDP_D_DATIN_SHIFTER_0_WRITE_MASK (_MK_MASK_CONST(0x1f)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_FIELD \ + (_MK_FIELD_CONST(0x1f, CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_SHIFT)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_RANGE (4:0) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_WOFFSET (0x0) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DATOUT_OFFSET_0 +#define CDP_D_DATOUT_OFFSET_0 (_MK_ADDR_CONST(0xf080)) +#define CDP_D_DATOUT_OFFSET_0_SECURE (0x0) +#define CDP_D_DATOUT_OFFSET_0_DUAL (0x0) +#define CDP_D_DATOUT_OFFSET_0_SCR (0) +#define CDP_D_DATOUT_OFFSET_0_WORD_COUNT (0x1) +#define CDP_D_DATOUT_OFFSET_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_OFFSET_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DATOUT_OFFSET_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_OFFSET_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_OFFSET_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DATOUT_OFFSET_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_SHIFT)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_RANGE (31:0) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_WOFFSET (0x0) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DATOUT_SCALE_0 +#define CDP_D_DATOUT_SCALE_0 (_MK_ADDR_CONST(0xf084)) +#define CDP_D_DATOUT_SCALE_0_SECURE (0x0) +#define CDP_D_DATOUT_SCALE_0_DUAL (0x0) +#define CDP_D_DATOUT_SCALE_0_SCR (0) +#define CDP_D_DATOUT_SCALE_0_WORD_COUNT (0x1) +#define CDP_D_DATOUT_SCALE_0_RESET_VAL (_MK_MASK_CONST(0x1)) +#define CDP_D_DATOUT_SCALE_0_RESET_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATOUT_SCALE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SCALE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SCALE_0_READ_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATOUT_SCALE_0_WRITE_MASK (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_FIELD \ + (_MK_FIELD_CONST(0xffff, CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_SHIFT)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_RANGE (15:0) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_WOFFSET (0x0) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_DEFAULT (_MK_MASK_CONST(0x1)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffff)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_DATOUT_SHIFTER_0 +#define CDP_D_DATOUT_SHIFTER_0 (_MK_ADDR_CONST(0xf088)) +#define CDP_D_DATOUT_SHIFTER_0_SECURE (0x0) +#define CDP_D_DATOUT_SHIFTER_0_DUAL (0x0) +#define CDP_D_DATOUT_SHIFTER_0_SCR (0) +#define CDP_D_DATOUT_SHIFTER_0_WORD_COUNT (0x1) +#define CDP_D_DATOUT_SHIFTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SHIFTER_0_RESET_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_D_DATOUT_SHIFTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SHIFTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SHIFTER_0_READ_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_D_DATOUT_SHIFTER_0_WRITE_MASK (_MK_MASK_CONST(0x3f)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_FIELD \ + (_MK_FIELD_CONST(0x3f, CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_SHIFT)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_RANGE (5:0) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_WOFFSET (0x0) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_DEFAULT_MASK \ + (_MK_MASK_CONST(0x3f)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_NAN_INPUT_NUM_0 +#define CDP_D_NAN_INPUT_NUM_0 (_MK_ADDR_CONST(0xf08c)) +#define CDP_D_NAN_INPUT_NUM_0_SECURE (0x0) +#define CDP_D_NAN_INPUT_NUM_0_DUAL (0x0) +#define CDP_D_NAN_INPUT_NUM_0_SCR (0) +#define CDP_D_NAN_INPUT_NUM_0_WORD_COUNT (0x1) +#define CDP_D_NAN_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_NAN_INPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_NAN_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_RANGE (31:0) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_WOFFSET (0x0) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_INF_INPUT_NUM_0 +#define CDP_D_INF_INPUT_NUM_0 (_MK_ADDR_CONST(0xf090)) +#define CDP_D_INF_INPUT_NUM_0_SECURE (0x0) +#define CDP_D_INF_INPUT_NUM_0_DUAL (0x0) +#define CDP_D_INF_INPUT_NUM_0_SCR (0) +#define CDP_D_INF_INPUT_NUM_0_WORD_COUNT (0x1) +#define CDP_D_INF_INPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_INF_INPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_INF_INPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_RANGE (31:0) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_WOFFSET (0x0) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_NAN_OUTPUT_NUM_0 +#define CDP_D_NAN_OUTPUT_NUM_0 (_MK_ADDR_CONST(0xf094)) +#define CDP_D_NAN_OUTPUT_NUM_0_SECURE (0x0) +#define CDP_D_NAN_OUTPUT_NUM_0_DUAL (0x0) +#define CDP_D_NAN_OUTPUT_NUM_0_SCR (0) +#define CDP_D_NAN_OUTPUT_NUM_0_WORD_COUNT (0x1) +#define CDP_D_NAN_OUTPUT_NUM_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_NAN_OUTPUT_NUM_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_NAN_OUTPUT_NUM_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_RANGE (31:0) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_WOFFSET (0x0) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_OUT_SATURATION_0 +#define CDP_D_OUT_SATURATION_0 (_MK_ADDR_CONST(0xf098)) +#define CDP_D_OUT_SATURATION_0_SECURE (0x0) +#define CDP_D_OUT_SATURATION_0_DUAL (0x0) +#define CDP_D_OUT_SATURATION_0_SCR (0) +#define CDP_D_OUT_SATURATION_0_WORD_COUNT (0x1) +#define CDP_D_OUT_SATURATION_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_OUT_SATURATION_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_OUT_SATURATION_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_OUT_SATURATION_0_OUT_SATURATION_SHIFT)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_RANGE (31:0) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_WOFFSET (0x0) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_PERF_ENABLE_0 +#define CDP_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0xf09c)) +#define CDP_D_PERF_ENABLE_0_SECURE (0x0) +#define CDP_D_PERF_ENABLE_0_DUAL (0x0) +#define CDP_D_PERF_ENABLE_0_SCR (0) +#define CDP_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define CDP_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x3)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_D_PERF_ENABLE_0_DMA_EN_SHIFT)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_RANGE (0:0) +#define CDP_D_PERF_ENABLE_0_DMA_EN_WOFFSET (0x0) +#define CDP_D_PERF_ENABLE_0_DMA_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_INIT_ENUM (DISABLE) +#define CDP_D_PERF_ENABLE_0_DMA_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_D_PERF_ENABLE_0_DMA_EN_ENABLE (_MK_ENUM_CONST(1)) + +#define CDP_D_PERF_ENABLE_0_LUT_EN_SHIFT (_MK_SHIFT_CONST(1)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_FIELD \ + (_MK_FIELD_CONST(0x1, CDP_D_PERF_ENABLE_0_LUT_EN_SHIFT)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_RANGE (1:1) +#define CDP_D_PERF_ENABLE_0_LUT_EN_WOFFSET (0x0) +#define CDP_D_PERF_ENABLE_0_LUT_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_INIT_ENUM (DISABLE) +#define CDP_D_PERF_ENABLE_0_LUT_EN_DISABLE (_MK_ENUM_CONST(0)) +#define CDP_D_PERF_ENABLE_0_LUT_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register CDP_D_PERF_WRITE_STALL_0 +#define CDP_D_PERF_WRITE_STALL_0 (_MK_ADDR_CONST(0xf0a0)) +#define CDP_D_PERF_WRITE_STALL_0_SECURE (0x0) +#define CDP_D_PERF_WRITE_STALL_0_DUAL (0x0) +#define CDP_D_PERF_WRITE_STALL_0_SCR (0) +#define CDP_D_PERF_WRITE_STALL_0_WORD_COUNT (0x1) +#define CDP_D_PERF_WRITE_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_WRITE_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_WRITE_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_RANGE (31:0) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_WOFFSET (0x0) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_PERF_LUT_UFLOW_0 +#define CDP_D_PERF_LUT_UFLOW_0 (_MK_ADDR_CONST(0xf0a4)) +#define CDP_D_PERF_LUT_UFLOW_0_SECURE (0x0) +#define CDP_D_PERF_LUT_UFLOW_0_DUAL (0x0) +#define CDP_D_PERF_LUT_UFLOW_0_SCR (0) +#define CDP_D_PERF_LUT_UFLOW_0_WORD_COUNT (0x1) +#define CDP_D_PERF_LUT_UFLOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_UFLOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_UFLOW_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_SHIFT)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_RANGE (31:0) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_WOFFSET (0x0) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_PERF_LUT_OFLOW_0 +#define CDP_D_PERF_LUT_OFLOW_0 (_MK_ADDR_CONST(0xf0a8)) +#define CDP_D_PERF_LUT_OFLOW_0_SECURE (0x0) +#define CDP_D_PERF_LUT_OFLOW_0_DUAL (0x0) +#define CDP_D_PERF_LUT_OFLOW_0_SCR (0) +#define CDP_D_PERF_LUT_OFLOW_0_WORD_COUNT (0x1) +#define CDP_D_PERF_LUT_OFLOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_OFLOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_OFLOW_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_SHIFT)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_RANGE (31:0) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_WOFFSET (0x0) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_PERF_LUT_HYBRID_0 +#define CDP_D_PERF_LUT_HYBRID_0 (_MK_ADDR_CONST(0xf0ac)) +#define CDP_D_PERF_LUT_HYBRID_0_SECURE (0x0) +#define CDP_D_PERF_LUT_HYBRID_0_DUAL (0x0) +#define CDP_D_PERF_LUT_HYBRID_0_SCR (0) +#define CDP_D_PERF_LUT_HYBRID_0_WORD_COUNT (0x1) +#define CDP_D_PERF_LUT_HYBRID_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_HYBRID_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_HYBRID_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_SHIFT)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_RANGE (31:0) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_WOFFSET (0x0) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_PERF_LUT_LE_HIT_0 +#define CDP_D_PERF_LUT_LE_HIT_0 (_MK_ADDR_CONST(0xf0b0)) +#define CDP_D_PERF_LUT_LE_HIT_0_SECURE (0x0) +#define CDP_D_PERF_LUT_LE_HIT_0_DUAL (0x0) +#define CDP_D_PERF_LUT_LE_HIT_0_SCR (0) +#define CDP_D_PERF_LUT_LE_HIT_0_WORD_COUNT (0x1) +#define CDP_D_PERF_LUT_LE_HIT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_LE_HIT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_LE_HIT_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_SHIFT)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_RANGE (31:0) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_WOFFSET (0x0) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_PERF_LUT_LO_HIT_0 +#define CDP_D_PERF_LUT_LO_HIT_0 (_MK_ADDR_CONST(0xf0b4)) +#define CDP_D_PERF_LUT_LO_HIT_0_SECURE (0x0) +#define CDP_D_PERF_LUT_LO_HIT_0_DUAL (0x0) +#define CDP_D_PERF_LUT_LO_HIT_0_SCR (0) +#define CDP_D_PERF_LUT_LO_HIT_0_WORD_COUNT (0x1) +#define CDP_D_PERF_LUT_LO_HIT_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_LO_HIT_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_LO_HIT_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_SHIFT)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_RANGE (31:0) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_WOFFSET (0x0) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register CDP_D_CYA_0 +#define CDP_D_CYA_0 (_MK_ADDR_CONST(0xf0b8)) +#define CDP_D_CYA_0_SECURE (0x0) +#define CDP_D_CYA_0_DUAL (0x0) +#define CDP_D_CYA_0_SCR (0) +#define CDP_D_CYA_0_WORD_COUNT (0x1) +#define CDP_D_CYA_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_CYA_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_CYA_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define CDP_D_CYA_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_CYA_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_CYA_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_CYA_0_CYA_SHIFT (_MK_SHIFT_CONST(0)) +#define CDP_D_CYA_0_CYA_FIELD \ + (_MK_FIELD_CONST(0xffffffff, CDP_D_CYA_0_CYA_SHIFT)) +#define CDP_D_CYA_0_CYA_RANGE (31:0) +#define CDP_D_CYA_0_CYA_WOFFSET (0x0) +#define CDP_D_CYA_0_CYA_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_CYA_0_CYA_DEFAULT_MASK (_MK_MASK_CONST(0xffffffff)) +#define CDP_D_CYA_0_CYA_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define CDP_D_CYA_0_CYA_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define CDP_D_CYA_0_CYA_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define CDP_D_CYA_0_CYA_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register RBK_S_STATUS_0 +#define RBK_S_STATUS_0 (_MK_ADDR_CONST(0x10000)) +#define RBK_S_STATUS_0_SECURE (0x0) +#define RBK_S_STATUS_0_DUAL (0x0) +#define RBK_S_STATUS_0_SCR (0) +#define RBK_S_STATUS_0_WORD_COUNT (0x1) +#define RBK_S_STATUS_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_RESET_MASK (_MK_MASK_CONST(0x30003)) +#define RBK_S_STATUS_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_READ_MASK (_MK_MASK_CONST(0x30003)) +#define RBK_S_STATUS_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_0_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_S_STATUS_0_STATUS_0_FIELD \ + (_MK_FIELD_CONST(0x3, RBK_S_STATUS_0_STATUS_0_SHIFT)) +#define RBK_S_STATUS_0_STATUS_0_RANGE (1:0) +#define RBK_S_STATUS_0_STATUS_0_WOFFSET (0x0) +#define RBK_S_STATUS_0_STATUS_0_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_0_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define RBK_S_STATUS_0_STATUS_0_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_0_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_0_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define RBK_S_STATUS_0_STATUS_0_INIT_ENUM (IDLE) +#define RBK_S_STATUS_0_STATUS_0_IDLE (_MK_ENUM_CONST(0)) +#define RBK_S_STATUS_0_STATUS_0_RUNNING (_MK_ENUM_CONST(1)) +#define RBK_S_STATUS_0_STATUS_0_PENDING (_MK_ENUM_CONST(2)) + +#define RBK_S_STATUS_0_STATUS_1_SHIFT (_MK_SHIFT_CONST(16)) +#define RBK_S_STATUS_0_STATUS_1_FIELD \ + (_MK_FIELD_CONST(0x3, RBK_S_STATUS_0_STATUS_1_SHIFT)) +#define RBK_S_STATUS_0_STATUS_1_RANGE (17:16) +#define RBK_S_STATUS_0_STATUS_1_WOFFSET (0x0) +#define RBK_S_STATUS_0_STATUS_1_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_1_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define RBK_S_STATUS_0_STATUS_1_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_1_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_1_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_S_STATUS_0_STATUS_1_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define RBK_S_STATUS_0_STATUS_1_INIT_ENUM (IDLE) +#define RBK_S_STATUS_0_STATUS_1_IDLE (_MK_ENUM_CONST(0)) +#define RBK_S_STATUS_0_STATUS_1_RUNNING (_MK_ENUM_CONST(1)) +#define RBK_S_STATUS_0_STATUS_1_PENDING (_MK_ENUM_CONST(2)) + + +// Register RBK_S_POINTER_0 +#define RBK_S_POINTER_0 (_MK_ADDR_CONST(0x10004)) +#define RBK_S_POINTER_0_SECURE (0x0) +#define RBK_S_POINTER_0_DUAL (0x0) +#define RBK_S_POINTER_0_SCR (0) +#define RBK_S_POINTER_0_WORD_COUNT (0x1) +#define RBK_S_POINTER_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_RESET_MASK (_MK_MASK_CONST(0x10001)) +#define RBK_S_POINTER_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_READ_MASK (_MK_MASK_CONST(0x10001)) +#define RBK_S_POINTER_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define RBK_S_POINTER_0_PRODUCER_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_S_POINTER_0_PRODUCER_FIELD \ + (_MK_FIELD_CONST(0x1, RBK_S_POINTER_0_PRODUCER_SHIFT)) +#define RBK_S_POINTER_0_PRODUCER_RANGE (0:0) +#define RBK_S_POINTER_0_PRODUCER_WOFFSET (0x0) +#define RBK_S_POINTER_0_PRODUCER_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_PRODUCER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define RBK_S_POINTER_0_PRODUCER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_PRODUCER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_PRODUCER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_PRODUCER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define RBK_S_POINTER_0_PRODUCER_INIT_ENUM (GROUP_0) +#define RBK_S_POINTER_0_PRODUCER_GROUP_0 (_MK_ENUM_CONST(0)) +#define RBK_S_POINTER_0_PRODUCER_GROUP_1 (_MK_ENUM_CONST(1)) + +#define RBK_S_POINTER_0_CONSUMER_SHIFT (_MK_SHIFT_CONST(16)) +#define RBK_S_POINTER_0_CONSUMER_FIELD \ + (_MK_FIELD_CONST(0x1, RBK_S_POINTER_0_CONSUMER_SHIFT)) +#define RBK_S_POINTER_0_CONSUMER_RANGE (16:16) +#define RBK_S_POINTER_0_CONSUMER_WOFFSET (0x0) +#define RBK_S_POINTER_0_CONSUMER_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_CONSUMER_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define RBK_S_POINTER_0_CONSUMER_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_CONSUMER_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_CONSUMER_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_S_POINTER_0_CONSUMER_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define RBK_S_POINTER_0_CONSUMER_INIT_ENUM (GROUP_0) +#define RBK_S_POINTER_0_CONSUMER_GROUP_0 (_MK_ENUM_CONST(0)) +#define RBK_S_POINTER_0_CONSUMER_GROUP_1 (_MK_ENUM_CONST(1)) + + +// Register RBK_D_OP_ENABLE_0 +#define RBK_D_OP_ENABLE_0 (_MK_ADDR_CONST(0x10008)) +#define RBK_D_OP_ENABLE_0_SECURE (0x0) +#define RBK_D_OP_ENABLE_0_DUAL (0x0) +#define RBK_D_OP_ENABLE_0_SCR (0) +#define RBK_D_OP_ENABLE_0_WORD_COUNT (0x1) +#define RBK_D_OP_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_OP_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_OP_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_OP_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_OP_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_OP_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_OP_ENABLE_0_OP_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_OP_ENABLE_0_OP_EN_FIELD \ + (_MK_FIELD_CONST(0x1, RBK_D_OP_ENABLE_0_OP_EN_SHIFT)) +#define RBK_D_OP_ENABLE_0_OP_EN_RANGE (0:0) +#define RBK_D_OP_ENABLE_0_OP_EN_WOFFSET (0x0) +#define RBK_D_OP_ENABLE_0_OP_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_OP_ENABLE_0_OP_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_OP_ENABLE_0_OP_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_OP_ENABLE_0_OP_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_OP_ENABLE_0_OP_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_D_OP_ENABLE_0_OP_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define RBK_D_OP_ENABLE_0_OP_EN_INIT_ENUM (DISABLE) +#define RBK_D_OP_ENABLE_0_OP_EN_DISABLE (_MK_ENUM_CONST(0)) +#define RBK_D_OP_ENABLE_0_OP_EN_ENABLE (_MK_ENUM_CONST(1)) + + +// Register RBK_D_MISC_CFG_0 +#define RBK_D_MISC_CFG_0 (_MK_ADDR_CONST(0x1000c)) +#define RBK_D_MISC_CFG_0_SECURE (0x0) +#define RBK_D_MISC_CFG_0_DUAL (0x0) +#define RBK_D_MISC_CFG_0_SCR (0) +#define RBK_D_MISC_CFG_0_WORD_COUNT (0x1) +#define RBK_D_MISC_CFG_0_RESET_VAL (_MK_MASK_CONST(0x100)) +#define RBK_D_MISC_CFG_0_RESET_MASK (_MK_MASK_CONST(0x303)) +#define RBK_D_MISC_CFG_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_READ_MASK (_MK_MASK_CONST(0x303)) +#define RBK_D_MISC_CFG_0_WRITE_MASK (_MK_MASK_CONST(0x303)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_FIELD \ + (_MK_FIELD_CONST(0x3, RBK_D_MISC_CFG_0_RUBIK_MODE_SHIFT)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_RANGE (1:0) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_WOFFSET (0x0) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_INIT_ENUM (CONTRACT) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_CONTRACT (_MK_ENUM_CONST(0)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_SPLIT (_MK_ENUM_CONST(1)) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_MERGE (_MK_ENUM_CONST(2)) + +#define RBK_D_MISC_CFG_0_IN_PRECISION_SHIFT (_MK_SHIFT_CONST(8)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_FIELD \ + (_MK_FIELD_CONST(0x3, RBK_D_MISC_CFG_0_IN_PRECISION_SHIFT)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_RANGE (9:8) +#define RBK_D_MISC_CFG_0_IN_PRECISION_WOFFSET (0x0) +#define RBK_D_MISC_CFG_0_IN_PRECISION_DEFAULT (_MK_MASK_CONST(0x1)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_DEFAULT_MASK (_MK_MASK_CONST(0x3)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_INIT_ENUM (INT16) +#define RBK_D_MISC_CFG_0_IN_PRECISION_INT8 (_MK_ENUM_CONST(0)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_INT16 (_MK_ENUM_CONST(1)) +#define RBK_D_MISC_CFG_0_IN_PRECISION_FP16 (_MK_ENUM_CONST(2)) + + +// Register RBK_D_DAIN_RAM_TYPE_0 +#define RBK_D_DAIN_RAM_TYPE_0 (_MK_ADDR_CONST(0x10010)) +#define RBK_D_DAIN_RAM_TYPE_0_SECURE (0x0) +#define RBK_D_DAIN_RAM_TYPE_0_DUAL (0x0) +#define RBK_D_DAIN_RAM_TYPE_0_SCR (0) +#define RBK_D_DAIN_RAM_TYPE_0_WORD_COUNT (0x1) +#define RBK_D_DAIN_RAM_TYPE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_RAM_TYPE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_DAIN_RAM_TYPE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_RAM_TYPE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_RAM_TYPE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_DAIN_RAM_TYPE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_RANGE (0:0) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_WOFFSET (0x0) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_INIT_ENUM (CVIF) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_CVIF (_MK_ENUM_CONST(0)) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_MCIF (_MK_ENUM_CONST(1)) + + +// Register RBK_D_DATAIN_SIZE_0_0 +#define RBK_D_DATAIN_SIZE_0_0 (_MK_ADDR_CONST(0x10014)) +#define RBK_D_DATAIN_SIZE_0_0_SECURE (0x0) +#define RBK_D_DATAIN_SIZE_0_0_DUAL (0x0) +#define RBK_D_DATAIN_SIZE_0_0_SCR (0) +#define RBK_D_DATAIN_SIZE_0_0_WORD_COUNT (0x1) +#define RBK_D_DATAIN_SIZE_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_RESET_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define RBK_D_DATAIN_SIZE_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_READ_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define RBK_D_DATAIN_SIZE_0_0_WRITE_MASK (_MK_MASK_CONST(0x1fff1fff)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_FIELD \ + (_MK_FIELD_CONST(0x1fff, RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_RANGE (12:0) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_WOFFSET (0x0) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT (_MK_SHIFT_CONST(16)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_FIELD \ + (_MK_FIELD_CONST(0x1fff, RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_RANGE (28:16) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_WOFFSET (0x0) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DATAIN_SIZE_1_0 +#define RBK_D_DATAIN_SIZE_1_0 (_MK_ADDR_CONST(0x10018)) +#define RBK_D_DATAIN_SIZE_1_0_SECURE (0x0) +#define RBK_D_DATAIN_SIZE_1_0_DUAL (0x0) +#define RBK_D_DATAIN_SIZE_1_0_SCR (0) +#define RBK_D_DATAIN_SIZE_1_0_WORD_COUNT (0x1) +#define RBK_D_DATAIN_SIZE_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAIN_SIZE_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_1_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAIN_SIZE_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_RANGE (12:0) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_WOFFSET (0x0) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAIN_ADDR_HIGH_0 +#define RBK_D_DAIN_ADDR_HIGH_0 (_MK_ADDR_CONST(0x1001c)) +#define RBK_D_DAIN_ADDR_HIGH_0_SECURE (0x0) +#define RBK_D_DAIN_ADDR_HIGH_0_DUAL (0x0) +#define RBK_D_DAIN_ADDR_HIGH_0_SCR (0) +#define RBK_D_DAIN_ADDR_HIGH_0_WORD_COUNT (0x1) +#define RBK_D_DAIN_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAIN_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAIN_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_SHIFT)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_RANGE (31:0) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_WOFFSET (0x0) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAIN_ADDR_LOW_0 +#define RBK_D_DAIN_ADDR_LOW_0 (_MK_ADDR_CONST(0x10020)) +#define RBK_D_DAIN_ADDR_LOW_0_SECURE (0x0) +#define RBK_D_DAIN_ADDR_LOW_0_DUAL (0x0) +#define RBK_D_DAIN_ADDR_LOW_0_SCR (0) +#define RBK_D_DAIN_ADDR_LOW_0_WORD_COUNT (0x1) +#define RBK_D_DAIN_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_SHIFT (_MK_SHIFT_CONST(5)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_SHIFT)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_RANGE (31:5) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_WOFFSET (0x0) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAIN_LINE_STRIDE_0 +#define RBK_D_DAIN_LINE_STRIDE_0 (_MK_ADDR_CONST(0x10024)) +#define RBK_D_DAIN_LINE_STRIDE_0_SECURE (0x0) +#define RBK_D_DAIN_LINE_STRIDE_0_DUAL (0x0) +#define RBK_D_DAIN_LINE_STRIDE_0_SCR (0) +#define RBK_D_DAIN_LINE_STRIDE_0_WORD_COUNT (0x1) +#define RBK_D_DAIN_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_SHIFT)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_RANGE (31:5) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_WOFFSET (0x0) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAIN_SURF_STRIDE_0 +#define RBK_D_DAIN_SURF_STRIDE_0 (_MK_ADDR_CONST(0x10028)) +#define RBK_D_DAIN_SURF_STRIDE_0_SECURE (0x0) +#define RBK_D_DAIN_SURF_STRIDE_0_DUAL (0x0) +#define RBK_D_DAIN_SURF_STRIDE_0_SCR (0) +#define RBK_D_DAIN_SURF_STRIDE_0_WORD_COUNT (0x1) +#define RBK_D_DAIN_SURF_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_SURF_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_SURF_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_SURF_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_SURF_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_SURF_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_SHIFT (_MK_SHIFT_CONST(5)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_SHIFT)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_RANGE (31:5) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_WOFFSET (0x0) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAIN_PLANAR_STRIDE_0 +#define RBK_D_DAIN_PLANAR_STRIDE_0 (_MK_ADDR_CONST(0x1002c)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_SECURE (0x0) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DUAL (0x0) +#define RBK_D_DAIN_PLANAR_STRIDE_0_SCR (0) +#define RBK_D_DAIN_PLANAR_STRIDE_0_WORD_COUNT (0x1) +#define RBK_D_DAIN_PLANAR_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_SHIFT)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_RANGE (31:5) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_WOFFSET (0x0) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAOUT_RAM_TYPE_0 +#define RBK_D_DAOUT_RAM_TYPE_0 (_MK_ADDR_CONST(0x10030)) +#define RBK_D_DAOUT_RAM_TYPE_0_SECURE (0x0) +#define RBK_D_DAOUT_RAM_TYPE_0_DUAL (0x0) +#define RBK_D_DAOUT_RAM_TYPE_0_SCR (0) +#define RBK_D_DAOUT_RAM_TYPE_0_WORD_COUNT (0x1) +#define RBK_D_DAOUT_RAM_TYPE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_RAM_TYPE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_DAOUT_RAM_TYPE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_RAM_TYPE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_RAM_TYPE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_DAOUT_RAM_TYPE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_FIELD \ + (_MK_FIELD_CONST(0x1, RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_SHIFT)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_RANGE (0:0) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_WOFFSET (0x0) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_INIT_ENUM (CVIF) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_CVIF (_MK_ENUM_CONST(0)) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_MCIF (_MK_ENUM_CONST(1)) + + +// Register RBK_D_DATAOUT_SIZE_1_0 +#define RBK_D_DATAOUT_SIZE_1_0 (_MK_ADDR_CONST(0x10034)) +#define RBK_D_DATAOUT_SIZE_1_0_SECURE (0x0) +#define RBK_D_DATAOUT_SIZE_1_0_DUAL (0x0) +#define RBK_D_DATAOUT_SIZE_1_0_SCR (0) +#define RBK_D_DATAOUT_SIZE_1_0_WORD_COUNT (0x1) +#define RBK_D_DATAOUT_SIZE_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAOUT_SIZE_1_0_RESET_MASK (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAOUT_SIZE_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAOUT_SIZE_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAOUT_SIZE_1_0_READ_MASK (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAOUT_SIZE_1_0_WRITE_MASK (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_FIELD \ + (_MK_FIELD_CONST(0x1fff, \ + RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_RANGE (12:0) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_WOFFSET (0x0) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1fff)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAOUT_ADDR_HIGH_0 +#define RBK_D_DAOUT_ADDR_HIGH_0 (_MK_ADDR_CONST(0x10038)) +#define RBK_D_DAOUT_ADDR_HIGH_0_SECURE (0x0) +#define RBK_D_DAOUT_ADDR_HIGH_0_DUAL (0x0) +#define RBK_D_DAOUT_ADDR_HIGH_0_SCR (0) +#define RBK_D_DAOUT_ADDR_HIGH_0_WORD_COUNT (0x1) +#define RBK_D_DAOUT_ADDR_HIGH_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAOUT_ADDR_HIGH_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAOUT_ADDR_HIGH_0_WRITE_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_SHIFT)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_RANGE (31:0) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_WOFFSET (0x0) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAOUT_ADDR_LOW_0 +#define RBK_D_DAOUT_ADDR_LOW_0 (_MK_ADDR_CONST(0x1003c)) +#define RBK_D_DAOUT_ADDR_LOW_0_SECURE (0x0) +#define RBK_D_DAOUT_ADDR_LOW_0_DUAL (0x0) +#define RBK_D_DAOUT_ADDR_LOW_0_SCR (0) +#define RBK_D_DAOUT_ADDR_LOW_0_WORD_COUNT (0x1) +#define RBK_D_DAOUT_ADDR_LOW_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_LOW_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_ADDR_LOW_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_LOW_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_LOW_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_ADDR_LOW_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_SHIFT (_MK_SHIFT_CONST(5)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_SHIFT)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_RANGE (31:5) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_WOFFSET (0x0) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAOUT_LINE_STRIDE_0 +#define RBK_D_DAOUT_LINE_STRIDE_0 (_MK_ADDR_CONST(0x10040)) +#define RBK_D_DAOUT_LINE_STRIDE_0_SECURE (0x0) +#define RBK_D_DAOUT_LINE_STRIDE_0_DUAL (0x0) +#define RBK_D_DAOUT_LINE_STRIDE_0_SCR (0) +#define RBK_D_DAOUT_LINE_STRIDE_0_WORD_COUNT (0x1) +#define RBK_D_DAOUT_LINE_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_SHIFT)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_RANGE (31:5) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_WOFFSET (0x0) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_CONTRACT_STRIDE_0_0 +#define RBK_D_CONTRACT_STRIDE_0_0 (_MK_ADDR_CONST(0x10044)) +#define RBK_D_CONTRACT_STRIDE_0_0_SECURE (0x0) +#define RBK_D_CONTRACT_STRIDE_0_0_DUAL (0x0) +#define RBK_D_CONTRACT_STRIDE_0_0_SCR (0) +#define RBK_D_CONTRACT_STRIDE_0_0_WORD_COUNT (0x1) +#define RBK_D_CONTRACT_STRIDE_0_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_0_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_CONTRACT_STRIDE_0_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_0_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_0_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_CONTRACT_STRIDE_0_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_SHIFT)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_RANGE (31:5) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_WOFFSET (0x0) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_CONTRACT_STRIDE_1_0 +#define RBK_D_CONTRACT_STRIDE_1_0 (_MK_ADDR_CONST(0x10048)) +#define RBK_D_CONTRACT_STRIDE_1_0_SECURE (0x0) +#define RBK_D_CONTRACT_STRIDE_1_0_DUAL (0x0) +#define RBK_D_CONTRACT_STRIDE_1_0_SCR (0) +#define RBK_D_CONTRACT_STRIDE_1_0_WORD_COUNT (0x1) +#define RBK_D_CONTRACT_STRIDE_1_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_1_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_CONTRACT_STRIDE_1_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_1_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_1_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_CONTRACT_STRIDE_1_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_SHIFT)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_RANGE (31:5) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_WOFFSET (0x0) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAOUT_SURF_STRIDE_0 +#define RBK_D_DAOUT_SURF_STRIDE_0 (_MK_ADDR_CONST(0x1004c)) +#define RBK_D_DAOUT_SURF_STRIDE_0_SECURE (0x0) +#define RBK_D_DAOUT_SURF_STRIDE_0_DUAL (0x0) +#define RBK_D_DAOUT_SURF_STRIDE_0_SCR (0) +#define RBK_D_DAOUT_SURF_STRIDE_0_WORD_COUNT (0x1) +#define RBK_D_DAOUT_SURF_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_SHIFT)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_RANGE (31:5) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_WOFFSET (0x0) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DAOUT_PLANAR_STRIDE_0 +#define RBK_D_DAOUT_PLANAR_STRIDE_0 (_MK_ADDR_CONST(0x10050)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_SECURE (0x0) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DUAL (0x0) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_SCR (0) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_WORD_COUNT (0x1) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_READ_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0xffffffe0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_SHIFT \ + (_MK_SHIFT_CONST(5)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x7ffffff, \ + RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_SHIFT)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_RANGE (31:5) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_WOFFSET (0x0) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x7ffffff)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_DECONV_STRIDE_0 +#define RBK_D_DECONV_STRIDE_0 (_MK_ADDR_CONST(0x10054)) +#define RBK_D_DECONV_STRIDE_0_SECURE (0x0) +#define RBK_D_DECONV_STRIDE_0_DUAL (0x0) +#define RBK_D_DECONV_STRIDE_0_SCR (0) +#define RBK_D_DECONV_STRIDE_0_WORD_COUNT (0x1) +#define RBK_D_DECONV_STRIDE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_RESET_MASK (_MK_MASK_CONST(0x1f001f)) +#define RBK_D_DECONV_STRIDE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_READ_MASK (_MK_MASK_CONST(0x1f001f)) +#define RBK_D_DECONV_STRIDE_0_WRITE_MASK (_MK_MASK_CONST(0x1f001f)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x1f, RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_SHIFT)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_RANGE (4:0) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_WOFFSET (0x0) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_SHIFT (_MK_SHIFT_CONST(16)) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_FIELD \ + (_MK_FIELD_CONST(0x1f, RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_SHIFT)) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_RANGE (20:16) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_WOFFSET (0x0) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_DEFAULT_MASK \ + (_MK_MASK_CONST(0x1f)) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_PERF_ENABLE_0 +#define RBK_D_PERF_ENABLE_0 (_MK_ADDR_CONST(0x10058)) +#define RBK_D_PERF_ENABLE_0_SECURE (0x0) +#define RBK_D_PERF_ENABLE_0_DUAL (0x0) +#define RBK_D_PERF_ENABLE_0_SCR (0) +#define RBK_D_PERF_ENABLE_0_WORD_COUNT (0x1) +#define RBK_D_PERF_ENABLE_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_ENABLE_0_RESET_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_PERF_ENABLE_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_ENABLE_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_ENABLE_0_READ_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_PERF_ENABLE_0_WRITE_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_FIELD \ + (_MK_FIELD_CONST(0x1, RBK_D_PERF_ENABLE_0_PERF_EN_SHIFT)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_RANGE (0:0) +#define RBK_D_PERF_ENABLE_0_PERF_EN_WOFFSET (0x0) +#define RBK_D_PERF_ENABLE_0_PERF_EN_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_DEFAULT_MASK (_MK_MASK_CONST(0x1)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_PARITY_PROTECTION (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_ENABLE_0_PERF_EN_PLATFORM_DEPENDENT (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_PERF_READ_STALL_0 +#define RBK_D_PERF_READ_STALL_0 (_MK_ADDR_CONST(0x1005c)) +#define RBK_D_PERF_READ_STALL_0_SECURE (0x0) +#define RBK_D_PERF_READ_STALL_0_DUAL (0x0) +#define RBK_D_PERF_READ_STALL_0_SCR (0) +#define RBK_D_PERF_READ_STALL_0_WORD_COUNT (0x1) +#define RBK_D_PERF_READ_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_PERF_READ_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_PERF_READ_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_SHIFT)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_RANGE (31:0) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_WOFFSET (0x0) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_SW_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// Register RBK_D_PERF_WRITE_STALL_0 +#define RBK_D_PERF_WRITE_STALL_0 (_MK_ADDR_CONST(0x10060)) +#define RBK_D_PERF_WRITE_STALL_0_SECURE (0x0) +#define RBK_D_PERF_WRITE_STALL_0_DUAL (0x0) +#define RBK_D_PERF_WRITE_STALL_0_SCR (0) +#define RBK_D_PERF_WRITE_STALL_0_WORD_COUNT (0x1) +#define RBK_D_PERF_WRITE_STALL_0_RESET_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_RESET_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_PERF_WRITE_STALL_0_SW_DEFAULT_VAL (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_SW_DEFAULT_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_READ_MASK (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_PERF_WRITE_STALL_0_WRITE_MASK (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_SHIFT (_MK_SHIFT_CONST(0)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_FIELD \ + (_MK_FIELD_CONST(0xffffffff, \ + RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_SHIFT)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_RANGE (31:0) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_WOFFSET (0x0) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_DEFAULT (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_DEFAULT_MASK \ + (_MK_MASK_CONST(0xffffffff)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_SW_DEFAULT \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_SW_DEFAULT_MASK \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_PARITY_PROTECTION \ + (_MK_MASK_CONST(0x0)) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_PLATFORM_DEPENDENT \ + (_MK_MASK_CONST(0x1)) + + +// +// REGISTER LIST +// +#define LIST_ARREGS(_op_) \ +(_op_(GLB_S_NVDLA_HW_VERSION_0) \ +_op_(GLB_S_INTR_MASK_0) \ +_op_(GLB_S_INTR_SET_0) \ +_op_(GLB_S_INTR_STATUS_0) \ +_op_(MCIF_CFG_RD_WEIGHT_0_0) \ +_op_(MCIF_CFG_RD_WEIGHT_1_0) \ +_op_(MCIF_CFG_RD_WEIGHT_2_0) \ +_op_(MCIF_CFG_WR_WEIGHT_0_0) \ +_op_(MCIF_CFG_WR_WEIGHT_1_0) \ +_op_(MCIF_CFG_OUTSTANDING_CNT_0) \ +_op_(MCIF_STATUS_0) \ +_op_(CVIF_CFG_RD_WEIGHT_0_0) \ +_op_(CVIF_CFG_RD_WEIGHT_1_0) \ +_op_(CVIF_CFG_RD_WEIGHT_2_0) \ +_op_(CVIF_CFG_WR_WEIGHT_0_0) \ +_op_(CVIF_CFG_WR_WEIGHT_1_0) \ +_op_(CVIF_CFG_OUTSTANDING_CNT_0) \ +_op_(CVIF_STATUS_0) \ +_op_(BDMA_CFG_SRC_ADDR_LOW_0) \ +_op_(BDMA_CFG_SRC_ADDR_HIGH_0) \ +_op_(BDMA_CFG_DST_ADDR_LOW_0) \ +_op_(BDMA_CFG_DST_ADDR_HIGH_0) \ +_op_(BDMA_CFG_LINE_0) \ +_op_(BDMA_CFG_CMD_0) \ +_op_(BDMA_CFG_LINE_REPEAT_0) \ +_op_(BDMA_CFG_SRC_LINE_0) \ +_op_(BDMA_CFG_DST_LINE_0) \ +_op_(BDMA_CFG_SURF_REPEAT_0) \ +_op_(BDMA_CFG_SRC_SURF_0) \ +_op_(BDMA_CFG_DST_SURF_0) \ +_op_(BDMA_CFG_OP_0) \ +_op_(BDMA_CFG_LAUNCH0_0) \ +_op_(BDMA_CFG_LAUNCH1_0) \ +_op_(BDMA_CFG_STATUS_0) \ +_op_(BDMA_STATUS_0) \ +_op_(BDMA_STATUS_GRP0_READ_STALL_0) \ +_op_(BDMA_STATUS_GRP0_WRITE_STALL_0) \ +_op_(BDMA_STATUS_GRP1_READ_STALL_0) \ +_op_(BDMA_STATUS_GRP1_WRITE_STALL_0) \ +_op_(CDMA_S_STATUS_0) \ +_op_(CDMA_S_POINTER_0) \ +_op_(CDMA_S_ARBITER_0) \ +_op_(CDMA_S_CBUF_FLUSH_STATUS_0) \ +_op_(CDMA_D_OP_ENABLE_0) \ +_op_(CDMA_D_MISC_CFG_0) \ +_op_(CDMA_D_DATAIN_FORMAT_0) \ +_op_(CDMA_D_DATAIN_SIZE_0_0) \ +_op_(CDMA_D_DATAIN_SIZE_1_0) \ +_op_(CDMA_D_DATAIN_SIZE_EXT_0_0) \ +_op_(CDMA_D_PIXEL_OFFSET_0) \ +_op_(CDMA_D_DAIN_RAM_TYPE_0) \ +_op_(CDMA_D_DAIN_ADDR_HIGH_0_0) \ +_op_(CDMA_D_DAIN_ADDR_LOW_0_0) \ +_op_(CDMA_D_DAIN_ADDR_HIGH_1_0) \ +_op_(CDMA_D_DAIN_ADDR_LOW_1_0) \ +_op_(CDMA_D_LINE_STRIDE_0) \ +_op_(CDMA_D_LINE_UV_STRIDE_0) \ +_op_(CDMA_D_SURF_STRIDE_0) \ +_op_(CDMA_D_DAIN_MAP_0) \ +_op_(CDMA_D_RESERVED_X_CFG_0) \ +_op_(CDMA_D_RESERVED_Y_CFG_0) \ +_op_(CDMA_D_BATCH_NUMBER_0) \ +_op_(CDMA_D_BATCH_STRIDE_0) \ +_op_(CDMA_D_ENTRY_PER_SLICE_0) \ +_op_(CDMA_D_FETCH_GRAIN_0) \ +_op_(CDMA_D_WEIGHT_FORMAT_0) \ +_op_(CDMA_D_WEIGHT_SIZE_0_0) \ +_op_(CDMA_D_WEIGHT_SIZE_1_0) \ +_op_(CDMA_D_WEIGHT_RAM_TYPE_0) \ +_op_(CDMA_D_WEIGHT_ADDR_HIGH_0) \ +_op_(CDMA_D_WEIGHT_ADDR_LOW_0) \ +_op_(CDMA_D_WEIGHT_BYTES_0) \ +_op_(CDMA_D_WGS_ADDR_HIGH_0) \ +_op_(CDMA_D_WGS_ADDR_LOW_0) \ +_op_(CDMA_D_WMB_ADDR_HIGH_0) \ +_op_(CDMA_D_WMB_ADDR_LOW_0) \ +_op_(CDMA_D_WMB_BYTES_0) \ +_op_(CDMA_D_MEAN_FORMAT_0) \ +_op_(CDMA_D_MEAN_GLOBAL_0_0) \ +_op_(CDMA_D_MEAN_GLOBAL_1_0) \ +_op_(CDMA_D_CVT_CFG_0) \ +_op_(CDMA_D_CVT_OFFSET_0) \ +_op_(CDMA_D_CVT_SCALE_0) \ +_op_(CDMA_D_CONV_STRIDE_0) \ +_op_(CDMA_D_ZERO_PADDING_0) \ +_op_(CDMA_D_ZERO_PADDING_VALUE_0) \ +_op_(CDMA_D_BANK_0) \ +_op_(CDMA_D_NAN_FLUSH_TO_ZERO_0) \ +_op_(CDMA_D_NAN_INPUT_DATA_NUM_0) \ +_op_(CDMA_D_NAN_INPUT_WEIGHT_NUM_0) \ +_op_(CDMA_D_INF_INPUT_DATA_NUM_0) \ +_op_(CDMA_D_INF_INPUT_WEIGHT_NUM_0) \ +_op_(CDMA_D_PERF_ENABLE_0) \ +_op_(CDMA_D_PERF_DAT_READ_STALL_0) \ +_op_(CDMA_D_PERF_WT_READ_STALL_0) \ +_op_(CDMA_D_PERF_DAT_READ_LATENCY_0) \ +_op_(CDMA_D_PERF_WT_READ_LATENCY_0) \ +_op_(CDMA_D_CYA_0) \ +_op_(CSC_S_STATUS_0) \ +_op_(CSC_S_POINTER_0) \ +_op_(CSC_D_OP_ENABLE_0) \ +_op_(CSC_D_MISC_CFG_0) \ +_op_(CSC_D_DATAIN_FORMAT_0) \ +_op_(CSC_D_DATAIN_SIZE_EXT_0_0) \ +_op_(CSC_D_DATAIN_SIZE_EXT_1_0) \ +_op_(CSC_D_BATCH_NUMBER_0) \ +_op_(CSC_D_POST_Y_EXTENSION_0) \ +_op_(CSC_D_ENTRY_PER_SLICE_0) \ +_op_(CSC_D_WEIGHT_FORMAT_0) \ +_op_(CSC_D_WEIGHT_SIZE_EXT_0_0) \ +_op_(CSC_D_WEIGHT_SIZE_EXT_1_0) \ +_op_(CSC_D_WEIGHT_BYTES_0) \ +_op_(CSC_D_WMB_BYTES_0) \ +_op_(CSC_D_DATAOUT_SIZE_0_0) \ +_op_(CSC_D_DATAOUT_SIZE_1_0) \ +_op_(CSC_D_ATOMICS_0) \ +_op_(CSC_D_RELEASE_0) \ +_op_(CSC_D_CONV_STRIDE_EXT_0) \ +_op_(CSC_D_DILATION_EXT_0) \ +_op_(CSC_D_ZERO_PADDING_0) \ +_op_(CSC_D_ZERO_PADDING_VALUE_0) \ +_op_(CSC_D_BANK_0) \ +_op_(CSC_D_PRA_CFG_0) \ +_op_(CSC_D_CYA_0) \ +_op_(CMAC_A_S_STATUS_0) \ +_op_(CMAC_A_S_POINTER_0) \ +_op_(CMAC_A_D_OP_ENABLE_0) \ +_op_(CMAC_A_D_MISC_CFG_0) \ +_op_(CMAC_B_S_STATUS_0) \ +_op_(CMAC_B_S_POINTER_0) \ +_op_(CMAC_B_D_OP_ENABLE_0) \ +_op_(CMAC_B_D_MISC_CFG_0) \ +_op_(CACC_S_STATUS_0) \ +_op_(CACC_S_POINTER_0) \ +_op_(CACC_D_OP_ENABLE_0) \ +_op_(CACC_D_MISC_CFG_0) \ +_op_(CACC_D_DATAOUT_SIZE_0_0) \ +_op_(CACC_D_DATAOUT_SIZE_1_0) \ +_op_(CACC_D_DATAOUT_ADDR_0) \ +_op_(CACC_D_BATCH_NUMBER_0) \ +_op_(CACC_D_LINE_STRIDE_0) \ +_op_(CACC_D_SURF_STRIDE_0) \ +_op_(CACC_D_DATAOUT_MAP_0) \ +_op_(CACC_D_CLIP_CFG_0) \ +_op_(CACC_D_OUT_SATURATION_0) \ +_op_(CACC_D_CYA_0) \ +_op_(SDP_RDMA_S_STATUS_0) \ +_op_(SDP_RDMA_S_POINTER_0) \ +_op_(SDP_RDMA_D_OP_ENABLE_0) \ +_op_(SDP_RDMA_D_DATA_CUBE_WIDTH_0) \ +_op_(SDP_RDMA_D_DATA_CUBE_HEIGHT_0) \ +_op_(SDP_RDMA_D_DATA_CUBE_CHANNEL_0) \ +_op_(SDP_RDMA_D_SRC_BASE_ADDR_LOW_0) \ +_op_(SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0) \ +_op_(SDP_RDMA_D_SRC_LINE_STRIDE_0) \ +_op_(SDP_RDMA_D_SRC_SURFACE_STRIDE_0) \ +_op_(SDP_RDMA_D_BRDMA_CFG_0) \ +_op_(SDP_RDMA_D_BS_BASE_ADDR_LOW_0) \ +_op_(SDP_RDMA_D_BS_BASE_ADDR_HIGH_0) \ +_op_(SDP_RDMA_D_BS_LINE_STRIDE_0) \ +_op_(SDP_RDMA_D_BS_SURFACE_STRIDE_0) \ +_op_(SDP_RDMA_D_BS_BATCH_STRIDE_0) \ +_op_(SDP_RDMA_D_NRDMA_CFG_0) \ +_op_(SDP_RDMA_D_BN_BASE_ADDR_LOW_0) \ +_op_(SDP_RDMA_D_BN_BASE_ADDR_HIGH_0) \ +_op_(SDP_RDMA_D_BN_LINE_STRIDE_0) \ +_op_(SDP_RDMA_D_BN_SURFACE_STRIDE_0) \ +_op_(SDP_RDMA_D_BN_BATCH_STRIDE_0) \ +_op_(SDP_RDMA_D_ERDMA_CFG_0) \ +_op_(SDP_RDMA_D_EW_BASE_ADDR_LOW_0) \ +_op_(SDP_RDMA_D_EW_BASE_ADDR_HIGH_0) \ +_op_(SDP_RDMA_D_EW_LINE_STRIDE_0) \ +_op_(SDP_RDMA_D_EW_SURFACE_STRIDE_0) \ +_op_(SDP_RDMA_D_EW_BATCH_STRIDE_0) \ +_op_(SDP_RDMA_D_FEATURE_MODE_CFG_0) \ +_op_(SDP_RDMA_D_SRC_DMA_CFG_0) \ +_op_(SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0) \ +_op_(SDP_RDMA_D_STATUS_INF_INPUT_NUM_0) \ +_op_(SDP_RDMA_D_PERF_ENABLE_0) \ +_op_(SDP_RDMA_D_PERF_MRDMA_READ_STALL_0) \ +_op_(SDP_RDMA_D_PERF_BRDMA_READ_STALL_0) \ +_op_(SDP_RDMA_D_PERF_NRDMA_READ_STALL_0) \ +_op_(SDP_RDMA_D_PERF_ERDMA_READ_STALL_0) \ +_op_(SDP_S_STATUS_0) \ +_op_(SDP_S_POINTER_0) \ +_op_(SDP_S_LUT_ACCESS_CFG_0) \ +_op_(SDP_S_LUT_ACCESS_DATA_0) \ +_op_(SDP_S_LUT_CFG_0) \ +_op_(SDP_S_LUT_INFO_0) \ +_op_(SDP_S_LUT_LE_START_0) \ +_op_(SDP_S_LUT_LE_END_0) \ +_op_(SDP_S_LUT_LO_START_0) \ +_op_(SDP_S_LUT_LO_END_0) \ +_op_(SDP_S_LUT_LE_SLOPE_SCALE_0) \ +_op_(SDP_S_LUT_LE_SLOPE_SHIFT_0) \ +_op_(SDP_S_LUT_LO_SLOPE_SCALE_0) \ +_op_(SDP_S_LUT_LO_SLOPE_SHIFT_0) \ +_op_(SDP_D_OP_ENABLE_0) \ +_op_(SDP_D_DATA_CUBE_WIDTH_0) \ +_op_(SDP_D_DATA_CUBE_HEIGHT_0) \ +_op_(SDP_D_DATA_CUBE_CHANNEL_0) \ +_op_(SDP_D_DST_BASE_ADDR_LOW_0) \ +_op_(SDP_D_DST_BASE_ADDR_HIGH_0) \ +_op_(SDP_D_DST_LINE_STRIDE_0) \ +_op_(SDP_D_DST_SURFACE_STRIDE_0) \ +_op_(SDP_D_DP_BS_CFG_0) \ +_op_(SDP_D_DP_BS_ALU_CFG_0) \ +_op_(SDP_D_DP_BS_ALU_SRC_VALUE_0) \ +_op_(SDP_D_DP_BS_MUL_CFG_0) \ +_op_(SDP_D_DP_BS_MUL_SRC_VALUE_0) \ +_op_(SDP_D_DP_BN_CFG_0) \ +_op_(SDP_D_DP_BN_ALU_CFG_0) \ +_op_(SDP_D_DP_BN_ALU_SRC_VALUE_0) \ +_op_(SDP_D_DP_BN_MUL_CFG_0) \ +_op_(SDP_D_DP_BN_MUL_SRC_VALUE_0) \ +_op_(SDP_D_DP_EW_CFG_0) \ +_op_(SDP_D_DP_EW_ALU_CFG_0) \ +_op_(SDP_D_DP_EW_ALU_SRC_VALUE_0) \ +_op_(SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0) \ +_op_(SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0) \ +_op_(SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0) \ +_op_(SDP_D_DP_EW_MUL_CFG_0) \ +_op_(SDP_D_DP_EW_MUL_SRC_VALUE_0) \ +_op_(SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0) \ +_op_(SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0) \ +_op_(SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0) \ +_op_(SDP_D_DP_EW_TRUNCATE_VALUE_0) \ +_op_(SDP_D_FEATURE_MODE_CFG_0) \ +_op_(SDP_D_DST_DMA_CFG_0) \ +_op_(SDP_D_DST_BATCH_STRIDE_0) \ +_op_(SDP_D_DATA_FORMAT_0) \ +_op_(SDP_D_CVT_OFFSET_0) \ +_op_(SDP_D_CVT_SCALE_0) \ +_op_(SDP_D_CVT_SHIFT_0) \ +_op_(SDP_D_STATUS_0) \ +_op_(SDP_D_STATUS_NAN_INPUT_NUM_0) \ +_op_(SDP_D_STATUS_INF_INPUT_NUM_0) \ +_op_(SDP_D_STATUS_NAN_OUTPUT_NUM_0) \ +_op_(SDP_D_PERF_ENABLE_0) \ +_op_(SDP_D_PERF_WDMA_WRITE_STALL_0) \ +_op_(SDP_D_PERF_LUT_UFLOW_0) \ +_op_(SDP_D_PERF_LUT_OFLOW_0) \ +_op_(SDP_D_PERF_OUT_SATURATION_0) \ +_op_(SDP_D_PERF_LUT_HYBRID_0) \ +_op_(SDP_D_PERF_LUT_LE_HIT_0) \ +_op_(SDP_D_PERF_LUT_LO_HIT_0) \ +_op_(PDP_RDMA_S_STATUS_0) \ +_op_(PDP_RDMA_S_POINTER_0) \ +_op_(PDP_RDMA_D_OP_ENABLE_0) \ +_op_(PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0) \ +_op_(PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0) \ +_op_(PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0) \ +_op_(PDP_RDMA_D_FLYING_MODE_0) \ +_op_(PDP_RDMA_D_SRC_BASE_ADDR_LOW_0) \ +_op_(PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0) \ +_op_(PDP_RDMA_D_SRC_LINE_STRIDE_0) \ +_op_(PDP_RDMA_D_SRC_SURFACE_STRIDE_0) \ +_op_(PDP_RDMA_D_SRC_RAM_CFG_0) \ +_op_(PDP_RDMA_D_DATA_FORMAT_0) \ +_op_(PDP_RDMA_D_OPERATION_MODE_CFG_0) \ +_op_(PDP_RDMA_D_POOLING_KERNEL_CFG_0) \ +_op_(PDP_RDMA_D_POOLING_PADDING_CFG_0) \ +_op_(PDP_RDMA_D_PARTIAL_WIDTH_IN_0) \ +_op_(PDP_RDMA_D_PERF_ENABLE_0) \ +_op_(PDP_RDMA_D_PERF_READ_STALL_0) \ +_op_(PDP_RDMA_D_CYA_0) \ +_op_(PDP_S_STATUS_0) \ +_op_(PDP_S_POINTER_0) \ +_op_(PDP_D_OP_ENABLE_0) \ +_op_(PDP_D_DATA_CUBE_IN_WIDTH_0) \ +_op_(PDP_D_DATA_CUBE_IN_HEIGHT_0) \ +_op_(PDP_D_DATA_CUBE_IN_CHANNEL_0) \ +_op_(PDP_D_DATA_CUBE_OUT_WIDTH_0) \ +_op_(PDP_D_DATA_CUBE_OUT_HEIGHT_0) \ +_op_(PDP_D_DATA_CUBE_OUT_CHANNEL_0) \ +_op_(PDP_D_OPERATION_MODE_CFG_0) \ +_op_(PDP_D_NAN_FLUSH_TO_ZERO_0) \ +_op_(PDP_D_PARTIAL_WIDTH_IN_0) \ +_op_(PDP_D_PARTIAL_WIDTH_OUT_0) \ +_op_(PDP_D_POOLING_KERNEL_CFG_0) \ +_op_(PDP_D_RECIP_KERNEL_WIDTH_0) \ +_op_(PDP_D_RECIP_KERNEL_HEIGHT_0) \ +_op_(PDP_D_POOLING_PADDING_CFG_0) \ +_op_(PDP_D_POOLING_PADDING_VALUE_1_CFG_0) \ +_op_(PDP_D_POOLING_PADDING_VALUE_2_CFG_0) \ +_op_(PDP_D_POOLING_PADDING_VALUE_3_CFG_0) \ +_op_(PDP_D_POOLING_PADDING_VALUE_4_CFG_0) \ +_op_(PDP_D_POOLING_PADDING_VALUE_5_CFG_0) \ +_op_(PDP_D_POOLING_PADDING_VALUE_6_CFG_0) \ +_op_(PDP_D_POOLING_PADDING_VALUE_7_CFG_0) \ +_op_(PDP_D_SRC_BASE_ADDR_LOW_0) \ +_op_(PDP_D_SRC_BASE_ADDR_HIGH_0) \ +_op_(PDP_D_SRC_LINE_STRIDE_0) \ +_op_(PDP_D_SRC_SURFACE_STRIDE_0) \ +_op_(PDP_D_DST_BASE_ADDR_LOW_0) \ +_op_(PDP_D_DST_BASE_ADDR_HIGH_0) \ +_op_(PDP_D_DST_LINE_STRIDE_0) \ +_op_(PDP_D_DST_SURFACE_STRIDE_0) \ +_op_(PDP_D_DST_RAM_CFG_0) \ +_op_(PDP_D_DATA_FORMAT_0) \ +_op_(PDP_D_INF_INPUT_NUM_0) \ +_op_(PDP_D_NAN_INPUT_NUM_0) \ +_op_(PDP_D_NAN_OUTPUT_NUM_0) \ +_op_(PDP_D_PERF_ENABLE_0) \ +_op_(PDP_D_PERF_WRITE_STALL_0) \ +_op_(PDP_D_CYA_0) \ +_op_(CDP_RDMA_S_STATUS_0) \ +_op_(CDP_RDMA_S_POINTER_0) \ +_op_(CDP_RDMA_D_OP_ENABLE_0) \ +_op_(CDP_RDMA_D_DATA_CUBE_WIDTH_0) \ +_op_(CDP_RDMA_D_DATA_CUBE_HEIGHT_0) \ +_op_(CDP_RDMA_D_DATA_CUBE_CHANNEL_0) \ +_op_(CDP_RDMA_D_SRC_BASE_ADDR_LOW_0) \ +_op_(CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0) \ +_op_(CDP_RDMA_D_SRC_LINE_STRIDE_0) \ +_op_(CDP_RDMA_D_SRC_SURFACE_STRIDE_0) \ +_op_(CDP_RDMA_D_SRC_DMA_CFG_0) \ +_op_(CDP_RDMA_D_SRC_COMPRESSION_EN_0) \ +_op_(CDP_RDMA_D_OPERATION_MODE_0) \ +_op_(CDP_RDMA_D_DATA_FORMAT_0) \ +_op_(CDP_RDMA_D_PERF_ENABLE_0) \ +_op_(CDP_RDMA_D_PERF_READ_STALL_0) \ +_op_(CDP_RDMA_D_CYA_0) \ +_op_(CDP_S_STATUS_0) \ +_op_(CDP_S_POINTER_0) \ +_op_(CDP_S_LUT_ACCESS_CFG_0) \ +_op_(CDP_S_LUT_ACCESS_DATA_0) \ +_op_(CDP_S_LUT_CFG_0) \ +_op_(CDP_S_LUT_INFO_0) \ +_op_(CDP_S_LUT_LE_START_LOW_0) \ +_op_(CDP_S_LUT_LE_START_HIGH_0) \ +_op_(CDP_S_LUT_LE_END_LOW_0) \ +_op_(CDP_S_LUT_LE_END_HIGH_0) \ +_op_(CDP_S_LUT_LO_START_LOW_0) \ +_op_(CDP_S_LUT_LO_START_HIGH_0) \ +_op_(CDP_S_LUT_LO_END_LOW_0) \ +_op_(CDP_S_LUT_LO_END_HIGH_0) \ +_op_(CDP_S_LUT_LE_SLOPE_SCALE_0) \ +_op_(CDP_S_LUT_LE_SLOPE_SHIFT_0) \ +_op_(CDP_S_LUT_LO_SLOPE_SCALE_0) \ +_op_(CDP_S_LUT_LO_SLOPE_SHIFT_0) \ +_op_(CDP_D_OP_ENABLE_0) \ +_op_(CDP_D_FUNC_BYPASS_0) \ +_op_(CDP_D_DST_BASE_ADDR_LOW_0) \ +_op_(CDP_D_DST_BASE_ADDR_HIGH_0) \ +_op_(CDP_D_DST_LINE_STRIDE_0) \ +_op_(CDP_D_DST_SURFACE_STRIDE_0) \ +_op_(CDP_D_DST_DMA_CFG_0) \ +_op_(CDP_D_DST_COMPRESSION_EN_0) \ +_op_(CDP_D_DATA_FORMAT_0) \ +_op_(CDP_D_NAN_FLUSH_TO_ZERO_0) \ +_op_(CDP_D_LRN_CFG_0) \ +_op_(CDP_D_DATIN_OFFSET_0) \ +_op_(CDP_D_DATIN_SCALE_0) \ +_op_(CDP_D_DATIN_SHIFTER_0) \ +_op_(CDP_D_DATOUT_OFFSET_0) \ +_op_(CDP_D_DATOUT_SCALE_0) \ +_op_(CDP_D_DATOUT_SHIFTER_0) \ +_op_(CDP_D_NAN_INPUT_NUM_0) \ +_op_(CDP_D_INF_INPUT_NUM_0) \ +_op_(CDP_D_NAN_OUTPUT_NUM_0) \ +_op_(CDP_D_OUT_SATURATION_0) \ +_op_(CDP_D_PERF_ENABLE_0) \ +_op_(CDP_D_PERF_WRITE_STALL_0) \ +_op_(CDP_D_PERF_LUT_UFLOW_0) \ +_op_(CDP_D_PERF_LUT_OFLOW_0) \ +_op_(CDP_D_PERF_LUT_HYBRID_0) \ +_op_(CDP_D_PERF_LUT_LE_HIT_0) \ +_op_(CDP_D_PERF_LUT_LO_HIT_0) \ +_op_(CDP_D_CYA_0) \ +_op_(RBK_S_STATUS_0) \ +_op_(RBK_S_POINTER_0) \ +_op_(RBK_D_OP_ENABLE_0) \ +_op_(RBK_D_MISC_CFG_0) \ +_op_(RBK_D_DAIN_RAM_TYPE_0) \ +_op_(RBK_D_DATAIN_SIZE_0_0) \ +_op_(RBK_D_DATAIN_SIZE_1_0) \ +_op_(RBK_D_DAIN_ADDR_HIGH_0) \ +_op_(RBK_D_DAIN_ADDR_LOW_0) \ +_op_(RBK_D_DAIN_LINE_STRIDE_0) \ +_op_(RBK_D_DAIN_SURF_STRIDE_0) \ +_op_(RBK_D_DAIN_PLANAR_STRIDE_0) \ +_op_(RBK_D_DAOUT_RAM_TYPE_0) \ +_op_(RBK_D_DATAOUT_SIZE_1_0) \ +_op_(RBK_D_DAOUT_ADDR_HIGH_0) \ +_op_(RBK_D_DAOUT_ADDR_LOW_0) \ +_op_(RBK_D_DAOUT_LINE_STRIDE_0) \ +_op_(RBK_D_CONTRACT_STRIDE_0_0) \ +_op_(RBK_D_CONTRACT_STRIDE_1_0) \ +_op_(RBK_D_DAOUT_SURF_STRIDE_0) \ +_op_(RBK_D_DAOUT_PLANAR_STRIDE_0) \ +_op_(RBK_D_DECONV_STRIDE_0) \ +_op_(RBK_D_PERF_ENABLE_0) \ +_op_(RBK_D_PERF_READ_STALL_0) \ +_op_(RBK_D_PERF_WRITE_STALL_0)) + + +// +// ADDRESS SPACES +// + +#define BASE_ADDRESS_NVDLA_GLB (0x00000000) +#define BASE_ADDRESS_NVDLA_MCIF (0x00002000) +#define BASE_ADDRESS_NVDLA_CVIF (0x00003000) +#define BASE_ADDRESS_NVDLA_BDMA (0x00004000) +#define BASE_ADDRESS_NVDLA_CDMA (0x00005000) +#define BASE_ADDRESS_NVDLA_CSC (0x00006000) +#define BASE_ADDRESS_NVDLA_CMAC_A (0x00007000) +#define BASE_ADDRESS_NVDLA_CMAC_B (0x00008000) +#define BASE_ADDRESS_NVDLA_CACC (0x00009000) +#define BASE_ADDRESS_NVDLA_SDP_RDMA (0x0000a000) +#define BASE_ADDRESS_NVDLA_SDP (0x0000b000) +#define BASE_ADDRESS_NVDLA_PDP_RDMA (0x0000c000) +#define BASE_ADDRESS_NVDLA_PDP (0x0000d000) +#define BASE_ADDRESS_NVDLA_CDP_RDMA (0x0000e000) +#define BASE_ADDRESS_NVDLA_CDP (0x0000f000) +#define BASE_ADDRESS_NVDLA_RBK (0x00010000) + +// +// ARNVDLA REGISTER BANKS +// + +#define GLB0_FIRST_REG (0x0000) +#define GLB0_LAST_REG (0x000c) +#define MCIF0_FIRST_REG (0x2000) +#define MCIF0_LAST_REG (0x2018) +#define CVIF0_FIRST_REG (0x3000) +#define CVIF0_LAST_REG (0x3018) +#define BDMA0_FIRST_REG (0x4000) +#define BDMA0_LAST_REG (0x4050) +#define CDMA0_FIRST_REG (0x5000) +#define CDMA0_LAST_REG (0x50e8) +#define CSC0_FIRST_REG (0x6000) +#define CSC0_LAST_REG (0x6064) +#define CMAC_A0_FIRST_REG (0x7000) +#define CMAC_A0_LAST_REG (0x700c) +#define CMAC_B0_FIRST_REG (0x8000) +#define CMAC_B0_LAST_REG (0x800c) +#define CACC0_FIRST_REG (0x9000) +#define CACC0_LAST_REG (0x9034) +#define SDP_RDMA0_FIRST_REG (0xa000) +#define SDP_RDMA0_LAST_REG (0xa090) +#define SDP0_FIRST_REG (0xb000) +#define SDP0_LAST_REG (0xb0f8) +#define PDP_RDMA0_FIRST_REG (0xc000) +#define PDP_RDMA0_LAST_REG (0xc04c) +#define PDP0_FIRST_REG (0xd000) +#define PDP0_LAST_REG (0xd09c) +#define CDP_RDMA0_FIRST_REG (0xe000) +#define CDP_RDMA0_LAST_REG (0xe040) +#define CDP0_FIRST_REG (0xf000) +#define CDP0_LAST_REG (0xf0b8) +#define RBK0_FIRST_REG (0x10000) +#define RBK0_LAST_REG (0x10060) + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST +#define _MK_SHIFT_CONST(_constant_) (_constant_) +#endif +#ifndef _MK_MASK_CONST +#define _MK_MASK_CONST(_constant_) (_constant_) +#endif +#ifndef _MK_ENUM_CONST +#define _MK_ENUM_CONST(_constant_) ((_constant_ ## UL)) +#endif +#ifndef _MK_ADDR_CONST +#define _MK_ADDR_CONST(_constant_) (_constant_) +#endif +#ifndef _MK_FIELD_CONST +#define _MK_FIELD_CONST(_mask_, _shift_) \ + ((_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_))) +#endif + +#endif // ifndef ___ARH_INC_ diff --git a/drivers/nvdla/include/opendla_small.h b/drivers/nvdla/include/opendla_small.h new file mode 100644 index 000000000000..dfcb3b0f847f --- /dev/null +++ b/drivers/nvdla/include/opendla_small.h @@ -0,0 +1,6433 @@ +/* + * Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of NVIDIA CORPORATION nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __OPENDLA_SMALL_H_ +#define __OPENDLA_SMALL_H_ + +// Register NVDLA_CFGROM_CFGROM_HW_VERSION_0 +#define NVDLA_CFGROM_CFGROM_HW_VERSION_0 _MK_ADDR_CONST(0x0) +#define NVDLA_CFGROM_CFGROM_HW_VERSION_0_HW_VERSION_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_HW_VERSION_0_HW_VERSION_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_HW_VERSION_0_HW_VERSION_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_GLB_DESC_0 +#define NVDLA_CFGROM_CFGROM_GLB_DESC_0 _MK_ADDR_CONST(0x4) +#define NVDLA_CFGROM_CFGROM_GLB_DESC_0_GLB_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_GLB_DESC_0_GLB_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_GLB_DESC_0_GLB_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CIF_DESC_0 +#define NVDLA_CFGROM_CFGROM_CIF_DESC_0 _MK_ADDR_CONST(0x8) +#define NVDLA_CFGROM_CFGROM_CIF_DESC_0_CIF_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CIF_DESC_0_CIF_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CIF_DESC_0_CIF_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CIF_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CIF_CAP_INCOMPAT_0 _MK_ADDR_CONST(0xc) +#define NVDLA_CFGROM_CFGROM_CIF_CAP_INCOMPAT_0_CIF_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CIF_CAP_INCOMPAT_0_CIF_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CIF_CAP_INCOMPAT_0_CIF_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CIF_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CIF_CAP_COMPAT_0 _MK_ADDR_CONST(0x10) +#define NVDLA_CFGROM_CFGROM_CIF_CAP_COMPAT_0_CIF_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CIF_CAP_COMPAT_0_CIF_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CIF_CAP_COMPAT_0_CIF_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CIF_BASE_WIDTH_0 +#define NVDLA_CFGROM_CFGROM_CIF_BASE_WIDTH_0 _MK_ADDR_CONST(0x14) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_WIDTH_0_CIF_BASE_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_WIDTH_0_CIF_BASE_WIDTH_FIELD _MK_FIELD_CONST(0xff, NVDLA_CFGROM_CFGROM_CIF_BASE_WIDTH_0_CIF_BASE_WIDTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CIF_BASE_LATENCY_0 +#define NVDLA_CFGROM_CFGROM_CIF_BASE_LATENCY_0 _MK_ADDR_CONST(0x18) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_LATENCY_0_CIF_BASE_LATENCY_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_LATENCY_0_CIF_BASE_LATENCY_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CIF_BASE_LATENCY_0_CIF_BASE_LATENCY_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CIF_BASE_BURST_LENGTH_MAX_0 +#define NVDLA_CFGROM_CFGROM_CIF_BASE_BURST_LENGTH_MAX_0 _MK_ADDR_CONST(0x1c) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_BURST_LENGTH_MAX_0_BASE_BURST_LENGTH_MAX_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_BURST_LENGTH_MAX_0_BASE_BURST_LENGTH_MAX_FIELD _MK_FIELD_CONST(0x7ffffff, NVDLA_CFGROM_CFGROM_CIF_BASE_BURST_LENGTH_MAX_0_BASE_BURST_LENGTH_MAX_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CIF_BASE_MEM_ADDR_WIDTH_0 +#define NVDLA_CFGROM_CFGROM_CIF_BASE_MEM_ADDR_WIDTH_0 _MK_ADDR_CONST(0x20) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_MEM_ADDR_WIDTH_0_CIF_BASE_MEM_ADDR_WIDTH_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_CFGROM_CFGROM_CIF_BASE_MEM_ADDR_WIDTH_0_CIF_BASE_MEM_ADDR_WIDTH_FIELD _MK_FIELD_CONST(0x7ffffff, NVDLA_CFGROM_CFGROM_CIF_BASE_MEM_ADDR_WIDTH_0_CIF_BASE_MEM_ADDR_WIDTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_DESC_0 +#define NVDLA_CFGROM_CFGROM_CDMA_DESC_0 _MK_ADDR_CONST(0x24) +#define NVDLA_CFGROM_CFGROM_CDMA_DESC_0_CDMA_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_DESC_0_CDMA_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_DESC_0_CDMA_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CDMA_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x28) +#define NVDLA_CFGROM_CFGROM_CDMA_CAP_INCOMPAT_0_CDMA_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_CAP_INCOMPAT_0_CDMA_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_CAP_INCOMPAT_0_CDMA_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CDMA_CAP_COMPAT_0 _MK_ADDR_CONST(0x2c) +#define NVDLA_CFGROM_CFGROM_CDMA_CAP_COMPAT_0_CDMA_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_CAP_COMPAT_0_CDMA_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_CAP_COMPAT_0_CDMA_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0x30) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_FEATURE_TYPES_0_CDMA_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_FEATURE_TYPES_0_CDMA_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CDMA_BASE_FEATURE_TYPES_0_CDMA_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_WEIGHT_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_WEIGHT_TYPES_0 _MK_ADDR_CONST(0x34) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_WEIGHT_TYPES_0_CDMA_BASE_WEIGHT_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_WEIGHT_TYPES_0_CDMA_BASE_WEIGHT_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CDMA_BASE_WEIGHT_TYPES_0_CDMA_BASE_WEIGHT_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_C_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_C_0 _MK_ADDR_CONST(0x38) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_C_0_CDMA_BASE_ATOMIC_C_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_C_0_CDMA_BASE_ATOMIC_C_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_C_0_CDMA_BASE_ATOMIC_C_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_K_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_K_0 _MK_ADDR_CONST(0x3c) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_K_0_CDMA_BASE_ATOMIC_K_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_K_0_CDMA_BASE_ATOMIC_K_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_K_0_CDMA_BASE_ATOMIC_K_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_M_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_M_0 _MK_ADDR_CONST(0x40) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_M_0_CDMA_BASE_ATOMIC_M_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_M_0_CDMA_BASE_ATOMIC_M_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_BASE_ATOMIC_M_0_CDMA_BASE_ATOMIC_M_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_NUM_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_NUM_0 _MK_ADDR_CONST(0x44) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_NUM_0_CDMA_BASE_CBUF_BANK_NUM_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_NUM_0_CDMA_BASE_CBUF_BANK_NUM_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_NUM_0_CDMA_BASE_CBUF_BANK_NUM_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_WIDTH_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_WIDTH_0 _MK_ADDR_CONST(0x48) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_WIDTH_0_CDMA_BASE_CBUF_BANK_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_WIDTH_0_CDMA_BASE_CBUF_BANK_WIDTH_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_WIDTH_0_CDMA_BASE_CBUF_BANK_WIDTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_DEPTH_0 +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_DEPTH_0 _MK_ADDR_CONST(0x4c) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_DEPTH_0_CDMA_BASE_CBUF_BANK_DEPTH_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_DEPTH_0_CDMA_BASE_CBUF_BANK_DEPTH_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_BASE_CBUF_BANK_DEPTH_0_CDMA_BASE_CBUF_BANK_DEPTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_MULTI_BATCH_MAX_0 +#define NVDLA_CFGROM_CFGROM_CDMA_MULTI_BATCH_MAX_0 _MK_ADDR_CONST(0x50) +#define NVDLA_CFGROM_CFGROM_CDMA_MULTI_BATCH_MAX_0_CDMA_MULTI_BATCH_MAX_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_MULTI_BATCH_MAX_0_CDMA_MULTI_BATCH_MAX_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_MULTI_BATCH_MAX_0_CDMA_MULTI_BATCH_MAX_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_PACKED_0 +#define NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_PACKED_0 _MK_ADDR_CONST(0x54) +#define NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_PACKED_0_CDMA_IMAGE_IN_FORMATS_PACKED_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_PACKED_0_CDMA_IMAGE_IN_FORMATS_PACKED_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_PACKED_0_CDMA_IMAGE_IN_FORMATS_PACKED_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_SEMI_0 +#define NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_SEMI_0 _MK_ADDR_CONST(0x58) +#define NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_SEMI_0_CDMA_IMAGE_IN_FORMATS_SEMI_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_SEMI_0_CDMA_IMAGE_IN_FORMATS_SEMI_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDMA_IMAGE_IN_FORMATS_SEMI_0_CDMA_IMAGE_IN_FORMATS_SEMI_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CBUF_DESC_0 +#define NVDLA_CFGROM_CFGROM_CBUF_DESC_0 _MK_ADDR_CONST(0x5c) +#define NVDLA_CFGROM_CFGROM_CBUF_DESC_0_CBUF_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CBUF_DESC_0_CBUF_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CBUF_DESC_0_CBUF_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CBUF_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CBUF_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x60) +#define NVDLA_CFGROM_CFGROM_CBUF_CAP_INCOMPAT_0_CBUF_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CBUF_CAP_INCOMPAT_0_CBUF_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CBUF_CAP_INCOMPAT_0_CBUF_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CBUF_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CBUF_CAP_COMPAT_0 _MK_ADDR_CONST(0x64) +#define NVDLA_CFGROM_CFGROM_CBUF_CAP_COMPAT_0_CBUF_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CBUF_CAP_COMPAT_0_CBUF_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CBUF_CAP_COMPAT_0_CBUF_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_NUM_0 +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_NUM_0 _MK_ADDR_CONST(0x68) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_NUM_0_CBUF_BASE_CBUF_BANK_NUM_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_NUM_0_CBUF_BASE_CBUF_BANK_NUM_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_NUM_0_CBUF_BASE_CBUF_BANK_NUM_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_WIDTH_0 +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_WIDTH_0 _MK_ADDR_CONST(0x6c) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_WIDTH_0_CBUF_BASE_CBUF_BANK_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_WIDTH_0_CBUF_BASE_CBUF_BANK_WIDTH_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_WIDTH_0_CBUF_BASE_CBUF_BANK_WIDTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_DEPTH_0 +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_DEPTH_0 _MK_ADDR_CONST(0x70) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_DEPTH_0_CBUF_BASE_CBUF_BANK_DEPTH_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_DEPTH_0_CBUF_BASE_CBUF_BANK_DEPTH_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CBUF_BASE_CBUF_BANK_DEPTH_0_CBUF_BASE_CBUF_BANK_DEPTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CBUF_BASE_CDMA_ID_0 +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CDMA_ID_0 _MK_ADDR_CONST(0x74) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CDMA_ID_0_CBUF_BASE_CDMA_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CBUF_BASE_CDMA_ID_0_CBUF_BASE_CDMA_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CBUF_BASE_CDMA_ID_0_CBUF_BASE_CDMA_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_DESC_0 +#define NVDLA_CFGROM_CFGROM_CSC_DESC_0 _MK_ADDR_CONST(0x78) +#define NVDLA_CFGROM_CFGROM_CSC_DESC_0_CSC_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_DESC_0_CSC_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_DESC_0_CSC_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CSC_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x7c) +#define NVDLA_CFGROM_CFGROM_CSC_CAP_INCOMPAT_0_CSC_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_CAP_INCOMPAT_0_CSC_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_CAP_INCOMPAT_0_CSC_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CSC_CAP_COMPAT_0 _MK_ADDR_CONST(0x80) +#define NVDLA_CFGROM_CFGROM_CSC_CAP_COMPAT_0_CSC_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_CAP_COMPAT_0_CSC_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_CAP_COMPAT_0_CSC_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0x84) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_FEATURE_TYPES_0_CSC_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_FEATURE_TYPES_0_CSC_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CSC_BASE_FEATURE_TYPES_0_CSC_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_WEIGHT_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_WEIGHT_TYPES_0 _MK_ADDR_CONST(0x88) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_WEIGHT_TYPES_0_CSC_BASE_WEIGHT_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_WEIGHT_TYPES_0_CSC_BASE_WEIGHT_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CSC_BASE_WEIGHT_TYPES_0_CSC_BASE_WEIGHT_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_C_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_C_0 _MK_ADDR_CONST(0x8c) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_C_0_CSC_BASE_ATOMIC_C_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_C_0_CSC_BASE_ATOMIC_C_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_C_0_CSC_BASE_ATOMIC_C_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_K_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_K_0 _MK_ADDR_CONST(0x90) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_K_0_CSC_BASE_ATOMIC_K_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_K_0_CSC_BASE_ATOMIC_K_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_K_0_CSC_BASE_ATOMIC_K_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_M_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_M_0 _MK_ADDR_CONST(0x94) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_M_0_CSC_BASE_ATOMIC_M_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_M_0_CSC_BASE_ATOMIC_M_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_BASE_ATOMIC_M_0_CSC_BASE_ATOMIC_M_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_NUM_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_NUM_0 _MK_ADDR_CONST(0x98) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_NUM_0_CSC_BASE_CBUF_BANK_NUM_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_NUM_0_CSC_BASE_CBUF_BANK_NUM_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_NUM_0_CSC_BASE_CBUF_BANK_NUM_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_WIDTH_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_WIDTH_0 _MK_ADDR_CONST(0x9c) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_WIDTH_0_CSC_BASE_CBUF_BANK_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_WIDTH_0_CSC_BASE_CBUF_BANK_WIDTH_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_WIDTH_0_CSC_BASE_CBUF_BANK_WIDTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_DEPTH_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_DEPTH_0 _MK_ADDR_CONST(0xa0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_DEPTH_0_CSC_BASE_CBUF_BANK_DEPTH_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_DEPTH_0_CSC_BASE_CBUF_BANK_DEPTH_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_BASE_CBUF_BANK_DEPTH_0_CSC_BASE_CBUF_BANK_DEPTH_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_BASE_CDMA_ID_0 +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CDMA_ID_0 _MK_ADDR_CONST(0xa4) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CDMA_ID_0_CSC_BASE_CDMA_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_BASE_CDMA_ID_0_CSC_BASE_CDMA_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_BASE_CDMA_ID_0_CSC_BASE_CDMA_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CSC_MULTI_BATCH_MAX_0 +#define NVDLA_CFGROM_CFGROM_CSC_MULTI_BATCH_MAX_0 _MK_ADDR_CONST(0xa8) +#define NVDLA_CFGROM_CFGROM_CSC_MULTI_BATCH_MAX_0_CSC_MULTI_BATCH_MAX_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CSC_MULTI_BATCH_MAX_0_CSC_MULTI_BATCH_MAX_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CSC_MULTI_BATCH_MAX_0_CSC_MULTI_BATCH_MAX_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_DESC_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_DESC_0 _MK_ADDR_CONST(0xac) +#define NVDLA_CFGROM_CFGROM_CMAC_A_DESC_0_CMAC_A_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_DESC_0_CMAC_A_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_A_DESC_0_CMAC_A_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_CAP_INCOMPAT_0 _MK_ADDR_CONST(0xb0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_CAP_INCOMPAT_0_CMAC_A_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_CAP_INCOMPAT_0_CMAC_A_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_A_CAP_INCOMPAT_0_CMAC_A_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_CAP_COMPAT_0 _MK_ADDR_CONST(0xb4) +#define NVDLA_CFGROM_CFGROM_CMAC_A_CAP_COMPAT_0_CMAC_A_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_CAP_COMPAT_0_CMAC_A_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_A_CAP_COMPAT_0_CMAC_A_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0xb8) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_FEATURE_TYPES_0_CMAC_A_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_FEATURE_TYPES_0_CMAC_A_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CMAC_A_BASE_FEATURE_TYPES_0_CMAC_A_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_BASE_WEIGHT_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_WEIGHT_TYPES_0 _MK_ADDR_CONST(0xbc) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_WEIGHT_TYPES_0_CMAC_A_BASE_WEIGHT_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_WEIGHT_TYPES_0_CMAC_A_BASE_WEIGHT_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CMAC_A_BASE_WEIGHT_TYPES_0_CMAC_A_BASE_WEIGHT_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_C_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_C_0 _MK_ADDR_CONST(0xc0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_C_0_CMAC_A_BASE_ATOMIC_C_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_C_0_CMAC_A_BASE_ATOMIC_C_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_C_0_CMAC_A_BASE_ATOMIC_C_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_K_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_K_0 _MK_ADDR_CONST(0xc4) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_K_0_CMAC_A_BASE_ATOMIC_K_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_K_0_CMAC_A_BASE_ATOMIC_K_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_A_BASE_ATOMIC_K_0_CMAC_A_BASE_ATOMIC_K_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_A_BASE_CDMA_ID_0 +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_CDMA_ID_0 _MK_ADDR_CONST(0xc8) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_CDMA_ID_0_CMAC_A_BASE_CDMA_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_A_BASE_CDMA_ID_0_CMAC_A_BASE_CDMA_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_A_BASE_CDMA_ID_0_CMAC_A_BASE_CDMA_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_DESC_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_DESC_0 _MK_ADDR_CONST(0xcc) +#define NVDLA_CFGROM_CFGROM_CMAC_B_DESC_0_CMAC_B_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_DESC_0_CMAC_B_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_B_DESC_0_CMAC_B_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_CAP_INCOMPAT_0 _MK_ADDR_CONST(0xd0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_CAP_INCOMPAT_0_CMAC_B_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_CAP_INCOMPAT_0_CMAC_B_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_B_CAP_INCOMPAT_0_CMAC_B_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_CAP_COMPAT_0 _MK_ADDR_CONST(0xd4) +#define NVDLA_CFGROM_CFGROM_CMAC_B_CAP_COMPAT_0_CMAC_B_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_CAP_COMPAT_0_CMAC_B_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_B_CAP_COMPAT_0_CMAC_B_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0xd8) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_FEATURE_TYPES_0_CMAC_B_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_FEATURE_TYPES_0_CMAC_B_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CMAC_B_BASE_FEATURE_TYPES_0_CMAC_B_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_BASE_WEIGHT_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_WEIGHT_TYPES_0 _MK_ADDR_CONST(0xdc) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_WEIGHT_TYPES_0_CMAC_B_BASE_WEIGHT_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_WEIGHT_TYPES_0_CMAC_B_BASE_WEIGHT_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CMAC_B_BASE_WEIGHT_TYPES_0_CMAC_B_BASE_WEIGHT_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_C_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_C_0 _MK_ADDR_CONST(0xe0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_C_0_CMAC_B_BASE_ATOMIC_C_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_C_0_CMAC_B_BASE_ATOMIC_C_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_C_0_CMAC_B_BASE_ATOMIC_C_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_K_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_K_0 _MK_ADDR_CONST(0xe4) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_K_0_CMAC_B_BASE_ATOMIC_K_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_K_0_CMAC_B_BASE_ATOMIC_K_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_B_BASE_ATOMIC_K_0_CMAC_B_BASE_ATOMIC_K_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CMAC_B_BASE_CDMA_ID_0 +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_CDMA_ID_0 _MK_ADDR_CONST(0xe8) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_CDMA_ID_0_CMAC_B_BASE_CDMA_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CMAC_B_BASE_CDMA_ID_0_CMAC_B_BASE_CDMA_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CMAC_B_BASE_CDMA_ID_0_CMAC_B_BASE_CDMA_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_DESC_0 +#define NVDLA_CFGROM_CFGROM_CACC_DESC_0 _MK_ADDR_CONST(0xec) +#define NVDLA_CFGROM_CFGROM_CACC_DESC_0_CACC_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_DESC_0_CACC_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CACC_DESC_0_CACC_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CACC_CAP_INCOMPAT_0 _MK_ADDR_CONST(0xf0) +#define NVDLA_CFGROM_CFGROM_CACC_CAP_INCOMPAT_0_CACC_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_CAP_INCOMPAT_0_CACC_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CACC_CAP_INCOMPAT_0_CACC_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CACC_CAP_COMPAT_0 _MK_ADDR_CONST(0xf4) +#define NVDLA_CFGROM_CFGROM_CACC_CAP_COMPAT_0_CACC_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_CAP_COMPAT_0_CACC_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CACC_CAP_COMPAT_0_CACC_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CACC_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0xf8) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_FEATURE_TYPES_0_CACC_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_FEATURE_TYPES_0_CACC_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CACC_BASE_FEATURE_TYPES_0_CACC_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_BASE_WEIGHT_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CACC_BASE_WEIGHT_TYPES_0 _MK_ADDR_CONST(0xfc) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_WEIGHT_TYPES_0_CACC_BASE_WEIGHT_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_WEIGHT_TYPES_0_CACC_BASE_WEIGHT_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CACC_BASE_WEIGHT_TYPES_0_CACC_BASE_WEIGHT_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_C_0 +#define NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_C_0 _MK_ADDR_CONST(0x100) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_C_0_CACC_BASE_ATOMIC_C_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_C_0_CACC_BASE_ATOMIC_C_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_C_0_CACC_BASE_ATOMIC_C_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_K_0 +#define NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_K_0 _MK_ADDR_CONST(0x104) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_K_0_CACC_BASE_ATOMIC_K_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_K_0_CACC_BASE_ATOMIC_K_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CACC_BASE_ATOMIC_K_0_CACC_BASE_ATOMIC_K_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_BASE_CDMA_ID_0 +#define NVDLA_CFGROM_CFGROM_CACC_BASE_CDMA_ID_0 _MK_ADDR_CONST(0x108) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_CDMA_ID_0_CACC_BASE_CDMA_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_BASE_CDMA_ID_0_CACC_BASE_CDMA_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CACC_BASE_CDMA_ID_0_CACC_BASE_CDMA_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CACC_MULTI_BATCH_MAX_0 +#define NVDLA_CFGROM_CFGROM_CACC_MULTI_BATCH_MAX_0 _MK_ADDR_CONST(0x10c) +#define NVDLA_CFGROM_CFGROM_CACC_MULTI_BATCH_MAX_0_CACC_MULTI_BATCH_MAX_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CACC_MULTI_BATCH_MAX_0_CACC_MULTI_BATCH_MAX_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CACC_MULTI_BATCH_MAX_0_CACC_MULTI_BATCH_MAX_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_RDMA_DESC_0 +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_DESC_0 _MK_ADDR_CONST(0x110) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_DESC_0_SDP_RDMA_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_DESC_0_SDP_RDMA_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_RDMA_DESC_0_SDP_RDMA_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x114) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_INCOMPAT_0_SDP_RDMA_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_INCOMPAT_0_SDP_RDMA_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_INCOMPAT_0_SDP_RDMA_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_COMPAT_0 _MK_ADDR_CONST(0x118) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_COMPAT_0_SDP_RDMA_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_COMPAT_0_SDP_RDMA_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_RDMA_CAP_COMPAT_0_SDP_RDMA_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_ATOMIC_M_0 +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_ATOMIC_M_0 _MK_ADDR_CONST(0x11c) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_ATOMIC_M_0_SDP_RDMA_BASE_ATOMIC_M_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_ATOMIC_M_0_SDP_RDMA_BASE_ATOMIC_M_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_ATOMIC_M_0_SDP_RDMA_BASE_ATOMIC_M_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_SDP_ID_0 +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_SDP_ID_0 _MK_ADDR_CONST(0x120) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_SDP_ID_0_SDP_RDMA_BASE_SDP_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_SDP_ID_0_SDP_RDMA_BASE_SDP_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_RDMA_BASE_SDP_ID_0_SDP_RDMA_BASE_SDP_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_DESC_0 +#define NVDLA_CFGROM_CFGROM_SDP_DESC_0 _MK_ADDR_CONST(0x124) +#define NVDLA_CFGROM_CFGROM_SDP_DESC_0_SDP_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_DESC_0_SDP_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_DESC_0_SDP_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_SDP_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x128) +#define NVDLA_CFGROM_CFGROM_SDP_CAP_INCOMPAT_0_SDP_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_CAP_INCOMPAT_0_SDP_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_CAP_INCOMPAT_0_SDP_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_SDP_CAP_COMPAT_0 _MK_ADDR_CONST(0x12c) +#define NVDLA_CFGROM_CFGROM_SDP_CAP_COMPAT_0_SDP_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_CAP_COMPAT_0_SDP_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_CAP_COMPAT_0_SDP_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_SDP_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0x130) +#define NVDLA_CFGROM_CFGROM_SDP_BASE_FEATURE_TYPES_0_SDP_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_BASE_FEATURE_TYPES_0_SDP_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_SDP_BASE_FEATURE_TYPES_0_SDP_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_BASE_WEIGHT_TYPES_0 +#define NVDLA_CFGROM_CFGROM_SDP_BASE_WEIGHT_TYPES_0 _MK_ADDR_CONST(0x134) +#define NVDLA_CFGROM_CFGROM_SDP_BASE_WEIGHT_TYPES_0_SDP_BASE_WEIGHT_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_BASE_WEIGHT_TYPES_0_SDP_BASE_WEIGHT_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_SDP_BASE_WEIGHT_TYPES_0_SDP_BASE_WEIGHT_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_BASE_CDMA_ID_0 +#define NVDLA_CFGROM_CFGROM_SDP_BASE_CDMA_ID_0 _MK_ADDR_CONST(0x138) +#define NVDLA_CFGROM_CFGROM_SDP_BASE_CDMA_ID_0_SDP_BASE_CDMA_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_BASE_CDMA_ID_0_SDP_BASE_CDMA_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_BASE_CDMA_ID_0_SDP_BASE_CDMA_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_MULTI_BATCH_MAX_0 +#define NVDLA_CFGROM_CFGROM_SDP_MULTI_BATCH_MAX_0 _MK_ADDR_CONST(0x13c) +#define NVDLA_CFGROM_CFGROM_SDP_MULTI_BATCH_MAX_0_SDP_MULTI_BATCH_MAX_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_MULTI_BATCH_MAX_0_SDP_MULTI_BATCH_MAX_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_MULTI_BATCH_MAX_0_SDP_MULTI_BATCH_MAX_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_BS_THROUGHPUT_0 +#define NVDLA_CFGROM_CFGROM_SDP_BS_THROUGHPUT_0 _MK_ADDR_CONST(0x140) +#define NVDLA_CFGROM_CFGROM_SDP_BS_THROUGHPUT_0_SDP_BS_THROUGHPUT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_BS_THROUGHPUT_0_SDP_BS_THROUGHPUT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_BS_THROUGHPUT_0_SDP_BS_THROUGHPUT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_BN_THROUGHPUT_0 +#define NVDLA_CFGROM_CFGROM_SDP_BN_THROUGHPUT_0 _MK_ADDR_CONST(0x144) +#define NVDLA_CFGROM_CFGROM_SDP_BN_THROUGHPUT_0_SDP_BN_THROUGHPUT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_BN_THROUGHPUT_0_SDP_BN_THROUGHPUT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_BN_THROUGHPUT_0_SDP_BN_THROUGHPUT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_SDP_EW_THROUGHPUT_0 +#define NVDLA_CFGROM_CFGROM_SDP_EW_THROUGHPUT_0 _MK_ADDR_CONST(0x148) +#define NVDLA_CFGROM_CFGROM_SDP_EW_THROUGHPUT_0_SDP_EW_THROUGHPUT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_SDP_EW_THROUGHPUT_0_SDP_EW_THROUGHPUT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_SDP_EW_THROUGHPUT_0_SDP_EW_THROUGHPUT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_RDMA_DESC_0 +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_DESC_0 _MK_ADDR_CONST(0x14c) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_DESC_0_PDP_RDMA_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_DESC_0_PDP_RDMA_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_RDMA_DESC_0_PDP_RDMA_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x150) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_INCOMPAT_0_PDP_RDMA_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_INCOMPAT_0_PDP_RDMA_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_INCOMPAT_0_PDP_RDMA_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_COMPAT_0 _MK_ADDR_CONST(0x154) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_COMPAT_0_PDP_RDMA_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_COMPAT_0_PDP_RDMA_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_RDMA_CAP_COMPAT_0_PDP_RDMA_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_ATOMIC_M_0 +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_ATOMIC_M_0 _MK_ADDR_CONST(0x158) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_ATOMIC_M_0_PDP_RDMA_BASE_ATOMIC_M_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_ATOMIC_M_0_PDP_RDMA_BASE_ATOMIC_M_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_ATOMIC_M_0_PDP_RDMA_BASE_ATOMIC_M_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_PDP_ID_0 +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_PDP_ID_0 _MK_ADDR_CONST(0x15c) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_PDP_ID_0_PDP_RDMA_BASE_PDP_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_PDP_ID_0_PDP_RDMA_BASE_PDP_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_RDMA_BASE_PDP_ID_0_PDP_RDMA_BASE_PDP_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_DESC_0 +#define NVDLA_CFGROM_CFGROM_PDP_DESC_0 _MK_ADDR_CONST(0x160) +#define NVDLA_CFGROM_CFGROM_PDP_DESC_0_PDP_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_DESC_0_PDP_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_DESC_0_PDP_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_PDP_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x164) +#define NVDLA_CFGROM_CFGROM_PDP_CAP_INCOMPAT_0_PDP_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_CAP_INCOMPAT_0_PDP_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_CAP_INCOMPAT_0_PDP_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_PDP_CAP_COMPAT_0 _MK_ADDR_CONST(0x168) +#define NVDLA_CFGROM_CFGROM_PDP_CAP_COMPAT_0_PDP_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_CAP_COMPAT_0_PDP_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_CAP_COMPAT_0_PDP_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_PDP_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0x16c) +#define NVDLA_CFGROM_CFGROM_PDP_BASE_FEATURE_TYPES_0_PDP_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_BASE_FEATURE_TYPES_0_PDP_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_PDP_BASE_FEATURE_TYPES_0_PDP_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_PDP_BASE_THROUGHPUT_0 +#define NVDLA_CFGROM_CFGROM_PDP_BASE_THROUGHPUT_0 _MK_ADDR_CONST(0x170) +#define NVDLA_CFGROM_CFGROM_PDP_BASE_THROUGHPUT_0_PDP_BASE_THROUGHPUT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_PDP_BASE_THROUGHPUT_0_PDP_BASE_THROUGHPUT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_PDP_BASE_THROUGHPUT_0_PDP_BASE_THROUGHPUT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_RDMA_DESC_0 +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_DESC_0 _MK_ADDR_CONST(0x174) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_DESC_0_CDP_RDMA_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_DESC_0_CDP_RDMA_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_RDMA_DESC_0_CDP_RDMA_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x178) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_INCOMPAT_0_CDP_RDMA_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_INCOMPAT_0_CDP_RDMA_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_INCOMPAT_0_CDP_RDMA_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_COMPAT_0 _MK_ADDR_CONST(0x17c) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_COMPAT_0_CDP_RDMA_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_COMPAT_0_CDP_RDMA_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_RDMA_CAP_COMPAT_0_CDP_RDMA_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_ATOMIC_M_0 +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_ATOMIC_M_0 _MK_ADDR_CONST(0x180) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_ATOMIC_M_0_CDP_RDMA_BASE_ATOMIC_M_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_ATOMIC_M_0_CDP_RDMA_BASE_ATOMIC_M_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_ATOMIC_M_0_CDP_RDMA_BASE_ATOMIC_M_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_CDP_ID_0 +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_CDP_ID_0 _MK_ADDR_CONST(0x184) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_CDP_ID_0_CDP_RDMA_BASE_CDP_ID_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_CDP_ID_0_CDP_RDMA_BASE_CDP_ID_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_RDMA_BASE_CDP_ID_0_CDP_RDMA_BASE_CDP_ID_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_DESC_0 +#define NVDLA_CFGROM_CFGROM_CDP_DESC_0 _MK_ADDR_CONST(0x188) +#define NVDLA_CFGROM_CFGROM_CDP_DESC_0_CDP_DESC_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_DESC_0_CDP_DESC_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_DESC_0_CDP_DESC_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_CAP_INCOMPAT_0 +#define NVDLA_CFGROM_CFGROM_CDP_CAP_INCOMPAT_0 _MK_ADDR_CONST(0x18c) +#define NVDLA_CFGROM_CFGROM_CDP_CAP_INCOMPAT_0_CDP_CAP_INCOMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_CAP_INCOMPAT_0_CDP_CAP_INCOMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_CAP_INCOMPAT_0_CDP_CAP_INCOMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_CAP_COMPAT_0 +#define NVDLA_CFGROM_CFGROM_CDP_CAP_COMPAT_0 _MK_ADDR_CONST(0x190) +#define NVDLA_CFGROM_CFGROM_CDP_CAP_COMPAT_0_CDP_CAP_COMPAT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_CAP_COMPAT_0_CDP_CAP_COMPAT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_CAP_COMPAT_0_CDP_CAP_COMPAT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_BASE_FEATURE_TYPES_0 +#define NVDLA_CFGROM_CFGROM_CDP_BASE_FEATURE_TYPES_0 _MK_ADDR_CONST(0x194) +#define NVDLA_CFGROM_CFGROM_CDP_BASE_FEATURE_TYPES_0_CDP_BASE_FEATURE_TYPES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_BASE_FEATURE_TYPES_0_CDP_BASE_FEATURE_TYPES_FIELD _MK_FIELD_CONST(0xfff, NVDLA_CFGROM_CFGROM_CDP_BASE_FEATURE_TYPES_0_CDP_BASE_FEATURE_TYPES_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_CDP_BASE_THROUGHPUT_0 +#define NVDLA_CFGROM_CFGROM_CDP_BASE_THROUGHPUT_0 _MK_ADDR_CONST(0x198) +#define NVDLA_CFGROM_CFGROM_CDP_BASE_THROUGHPUT_0_CDP_BASE_THROUGHPUT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_CDP_BASE_THROUGHPUT_0_CDP_BASE_THROUGHPUT_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_CDP_BASE_THROUGHPUT_0_CDP_BASE_THROUGHPUT_SHIFT) + + +// Register NVDLA_CFGROM_CFGROM_END_OF_LIST_0 +#define NVDLA_CFGROM_CFGROM_END_OF_LIST_0 _MK_ADDR_CONST(0x19c) +#define NVDLA_CFGROM_CFGROM_END_OF_LIST_0_END_OF_LIST_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CFGROM_CFGROM_END_OF_LIST_0_END_OF_LIST_FIELD _MK_FIELD_CONST(0xffffffff, NVDLA_CFGROM_CFGROM_END_OF_LIST_0_END_OF_LIST_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register GLB_S_NVDLA_HW_VERSION_0 +#define GLB_S_NVDLA_HW_VERSION_0 _MK_ADDR_CONST(0x1000) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_SHIFT _MK_SHIFT_CONST(0) +#define GLB_S_NVDLA_HW_VERSION_0_MAJOR_FIELD _MK_FIELD_CONST(0xff, GLB_S_NVDLA_HW_VERSION_0_MAJOR_SHIFT) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_SHIFT _MK_SHIFT_CONST(8) +#define GLB_S_NVDLA_HW_VERSION_0_MINOR_FIELD _MK_FIELD_CONST(0xffff, GLB_S_NVDLA_HW_VERSION_0_MINOR_SHIFT) + + +// Register GLB_S_INTR_MASK_0 +#define GLB_S_INTR_MASK_0 _MK_ADDR_CONST(0x1004) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_SHIFT _MK_SHIFT_CONST(0) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_SDP_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_SHIFT _MK_SHIFT_CONST(1) +#define GLB_S_INTR_MASK_0_SDP_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_SDP_DONE_MASK1_SHIFT) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_SHIFT _MK_SHIFT_CONST(2) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDP_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_SHIFT _MK_SHIFT_CONST(3) +#define GLB_S_INTR_MASK_0_CDP_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDP_DONE_MASK1_SHIFT) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_SHIFT _MK_SHIFT_CONST(4) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_PDP_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_SHIFT _MK_SHIFT_CONST(5) +#define GLB_S_INTR_MASK_0_PDP_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_PDP_DONE_MASK1_SHIFT) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_SHIFT _MK_SHIFT_CONST(6) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_BDMA_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_SHIFT _MK_SHIFT_CONST(7) +#define GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_BDMA_DONE_MASK1_SHIFT) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_SHIFT _MK_SHIFT_CONST(8) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_RUBIK_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_SHIFT _MK_SHIFT_CONST(9) +#define GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_RUBIK_DONE_MASK1_SHIFT) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_SHIFT _MK_SHIFT_CONST(16) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_SHIFT _MK_SHIFT_CONST(17) +#define GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_DAT_DONE_MASK1_SHIFT) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_SHIFT _MK_SHIFT_CONST(18) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_SHIFT _MK_SHIFT_CONST(19) +#define GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CDMA_WT_DONE_MASK1_SHIFT) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_SHIFT _MK_SHIFT_CONST(20) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CACC_DONE_MASK0_SHIFT) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_SHIFT _MK_SHIFT_CONST(21) +#define GLB_S_INTR_MASK_0_CACC_DONE_MASK1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_MASK_0_CACC_DONE_MASK1_SHIFT) + + +// Register GLB_S_INTR_SET_0 +#define GLB_S_INTR_SET_0 _MK_ADDR_CONST(0x1008) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_SHIFT _MK_SHIFT_CONST(0) +#define GLB_S_INTR_SET_0_SDP_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_SDP_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_SHIFT _MK_SHIFT_CONST(1) +#define GLB_S_INTR_SET_0_SDP_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_SDP_DONE_SET1_SHIFT) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_SHIFT _MK_SHIFT_CONST(2) +#define GLB_S_INTR_SET_0_CDP_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDP_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_SHIFT _MK_SHIFT_CONST(3) +#define GLB_S_INTR_SET_0_CDP_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDP_DONE_SET1_SHIFT) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_SHIFT _MK_SHIFT_CONST(4) +#define GLB_S_INTR_SET_0_PDP_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_PDP_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_SHIFT _MK_SHIFT_CONST(5) +#define GLB_S_INTR_SET_0_PDP_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_PDP_DONE_SET1_SHIFT) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_SHIFT _MK_SHIFT_CONST(6) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_BDMA_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_SHIFT _MK_SHIFT_CONST(7) +#define GLB_S_INTR_SET_0_BDMA_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_BDMA_DONE_SET1_SHIFT) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_SHIFT _MK_SHIFT_CONST(8) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_RUBIK_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_SHIFT _MK_SHIFT_CONST(9) +#define GLB_S_INTR_SET_0_RUBIK_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_RUBIK_DONE_SET1_SHIFT) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_SHIFT _MK_SHIFT_CONST(16) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_SHIFT _MK_SHIFT_CONST(17) +#define GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_DAT_DONE_SET1_SHIFT) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_SHIFT _MK_SHIFT_CONST(18) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_WT_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_SHIFT _MK_SHIFT_CONST(19) +#define GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CDMA_WT_DONE_SET1_SHIFT) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_SHIFT _MK_SHIFT_CONST(20) +#define GLB_S_INTR_SET_0_CACC_DONE_SET0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CACC_DONE_SET0_SHIFT) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_SHIFT _MK_SHIFT_CONST(21) +#define GLB_S_INTR_SET_0_CACC_DONE_SET1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_SET_0_CACC_DONE_SET1_SHIFT) + + +// Register GLB_S_INTR_STATUS_0 +#define GLB_S_INTR_STATUS_0 _MK_ADDR_CONST(0x100c) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(0) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_SDP_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(1) +#define GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_SDP_DONE_STATUS1_SHIFT) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(2) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDP_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(3) +#define GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDP_DONE_STATUS1_SHIFT) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(4) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_PDP_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(5) +#define GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_PDP_DONE_STATUS1_SHIFT) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(6) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(7) +#define GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_BDMA_DONE_STATUS1_SHIFT) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(8) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(9) +#define GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_RUBIK_DONE_STATUS1_SHIFT) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(16) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(17) +#define GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDMA_DAT_DONE_STATUS1_SHIFT) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(18) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(19) +#define GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CDMA_WT_DONE_STATUS1_SHIFT) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_SHIFT _MK_SHIFT_CONST(20) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CACC_DONE_STATUS0_SHIFT) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_SHIFT _MK_SHIFT_CONST(21) +#define GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_FIELD _MK_FIELD_CONST(0x1, GLB_S_INTR_STATUS_0_CACC_DONE_STATUS1_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register NVDLA_MCIF_CFG_RD_WEIGHT_0_0 +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0 _MK_ADDR_CONST(0x2000) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT) + + +// Register NVDLA_MCIF_CFG_RD_WEIGHT_1_0 +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0 _MK_ADDR_CONST(0x2004) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT) + + +// Register NVDLA_MCIF_CFG_RD_WEIGHT_2_0 +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0 _MK_ADDR_CONST(0x2008) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT) + + +// Register NVDLA_MCIF_CFG_WR_WEIGHT_0_0 +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0 _MK_ADDR_CONST(0x200c) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT) + + +// Register NVDLA_MCIF_CFG_WR_WEIGHT_1_0 +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0 _MK_ADDR_CONST(0x2010) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT) + + +// Register NVDLA_MCIF_CFG_OUTSTANDING_CNT_0 +#define NVDLA_MCIF_CFG_OUTSTANDING_CNT_0 _MK_ADDR_CONST(0x2014) +#define NVDLA_MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT) +#define NVDLA_MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_FIELD _MK_FIELD_CONST(0xff, NVDLA_MCIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT) + + +// Register NVDLA_MCIF_STATUS_0 +#define NVDLA_MCIF_STATUS_0 _MK_ADDR_CONST(0x2018) +#define NVDLA_MCIF_STATUS_0_IDLE_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_MCIF_STATUS_0_IDLE_FIELD _MK_FIELD_CONST(0x1, NVDLA_MCIF_STATUS_0_IDLE_SHIFT) +#define NVDLA_MCIF_STATUS_0_IDLE_NO _MK_ENUM_CONST(0x0) +#define NVDLA_MCIF_STATUS_0_IDLE_YES _MK_ENUM_CONST(0x1) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register CDMA_S_STATUS_0 +#define CDMA_S_STATUS_0 _MK_ADDR_CONST(0x3000) +#define CDMA_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, CDMA_S_STATUS_0_STATUS_0_SHIFT) +#define CDMA_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define CDMA_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define CDMA_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define CDMA_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, CDMA_S_STATUS_0_STATUS_1_SHIFT) +#define CDMA_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define CDMA_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define CDMA_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register CDMA_S_POINTER_0 +#define CDMA_S_POINTER_0 _MK_ADDR_CONST(0x3004) +#define CDMA_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, CDMA_S_POINTER_0_PRODUCER_SHIFT) +#define CDMA_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CDMA_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define CDMA_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, CDMA_S_POINTER_0_CONSUMER_SHIFT) +#define CDMA_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CDMA_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register CDMA_S_ARBITER_0 +#define CDMA_S_ARBITER_0 _MK_ADDR_CONST(0x3008) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_S_ARBITER_0_ARB_WEIGHT_FIELD _MK_FIELD_CONST(0xf, CDMA_S_ARBITER_0_ARB_WEIGHT_SHIFT) +#define CDMA_S_ARBITER_0_ARB_WMB_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_S_ARBITER_0_ARB_WMB_FIELD _MK_FIELD_CONST(0xf, CDMA_S_ARBITER_0_ARB_WMB_SHIFT) + + +// Register CDMA_S_CBUF_FLUSH_STATUS_0 +#define CDMA_S_CBUF_FLUSH_STATUS_0 _MK_ADDR_CONST(0x300c) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_FIELD _MK_FIELD_CONST(0x1, CDMA_S_CBUF_FLUSH_STATUS_0_FLUSH_DONE_SHIFT) + + +// Register CDMA_D_OP_ENABLE_0 +#define CDMA_D_OP_ENABLE_0 _MK_ADDR_CONST(0x3010) +#define CDMA_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, CDMA_D_OP_ENABLE_0_OP_EN_SHIFT) +#define CDMA_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_MISC_CFG_0 +#define CDMA_D_MISC_CFG_0 _MK_ADDR_CONST(0x3014) +#define CDMA_D_MISC_CFG_0_CONV_MODE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_MISC_CFG_0_CONV_MODE_FIELD _MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_CONV_MODE_SHIFT) +#define CDMA_D_MISC_CFG_0_CONV_MODE_DIRECT _MK_ENUM_CONST(0x0) +#define CDMA_D_MISC_CFG_0_CONV_MODE_WINOGRAD _MK_ENUM_CONST(0x1) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_SHIFT _MK_SHIFT_CONST(8) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_FIELD _MK_FIELD_CONST(0x3, CDMA_D_MISC_CFG_0_IN_PRECISION_SHIFT) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define CDMA_D_MISC_CFG_0_IN_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_SHIFT _MK_SHIFT_CONST(12) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_FIELD _MK_FIELD_CONST(0x3, CDMA_D_MISC_CFG_0_PROC_PRECISION_SHIFT) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define CDMA_D_MISC_CFG_0_PROC_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_FIELD _MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_DATA_REUSE_SHIFT) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_MISC_CFG_0_DATA_REUSE_ENABLE _MK_ENUM_CONST(0x1) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT _MK_SHIFT_CONST(20) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_FIELD _MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_MISC_CFG_0_WEIGHT_REUSE_ENABLE _MK_ENUM_CONST(0x1) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT _MK_SHIFT_CONST(24) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_FIELD _MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_MISC_CFG_0_SKIP_DATA_RLS_ENABLE _MK_ENUM_CONST(0x1) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT _MK_SHIFT_CONST(28) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_FIELD _MK_FIELD_CONST(0x1, CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_MISC_CFG_0_SKIP_WEIGHT_RLS_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_DATAIN_FORMAT_0 +#define CDMA_D_DATAIN_FORMAT_0 _MK_ADDR_CONST(0x3018) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FIELD _MK_FIELD_CONST(0x1, CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FEATURE _MK_ENUM_CONST(0x0) +#define CDMA_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PIXEL _MK_ENUM_CONST(0x1) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_SHIFT _MK_SHIFT_CONST(8) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_FIELD _MK_FIELD_CONST(0x3f, CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_SHIFT) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R8 _MK_ENUM_CONST(0x0) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R10 _MK_ENUM_CONST(0x1) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R12 _MK_ENUM_CONST(0x2) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R16 _MK_ENUM_CONST(0x3) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R16_I _MK_ENUM_CONST(0x4) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R16_F _MK_ENUM_CONST(0x5) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16B16G16R16 _MK_ENUM_CONST(0x6) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_X16B16G16R16 _MK_ENUM_CONST(0x7) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16B16G16R16_F _MK_ENUM_CONST(0x8) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16Y16U16V16 _MK_ENUM_CONST(0x9) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_V16U16Y16A16 _MK_ENUM_CONST(0xa) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A16Y16U16V16_F _MK_ENUM_CONST(0xb) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A8B8G8R8 _MK_ENUM_CONST(0xc) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A8R8G8B8 _MK_ENUM_CONST(0xd) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_B8G8R8A8 _MK_ENUM_CONST(0xe) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R8G8B8A8 _MK_ENUM_CONST(0xf) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_X8B8G8R8 _MK_ENUM_CONST(0x10) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_X8R8G8B8 _MK_ENUM_CONST(0x11) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_B8G8R8X8 _MK_ENUM_CONST(0x12) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R8G8B8X8 _MK_ENUM_CONST(0x13) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A2B10G10R10 _MK_ENUM_CONST(0x14) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A2R10G10B10 _MK_ENUM_CONST(0x15) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_B10G10R10A2 _MK_ENUM_CONST(0x16) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_R10G10B10A2 _MK_ENUM_CONST(0x17) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A2Y10U10V10 _MK_ENUM_CONST(0x18) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_V10U10Y10A2 _MK_ENUM_CONST(0x19) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_A8Y8U8V8 _MK_ENUM_CONST(0x1a) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_V8U8Y8A8 _MK_ENUM_CONST(0x1b) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y8___U8V8_N444 _MK_ENUM_CONST(0x1c) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y8___V8U8_N444 _MK_ENUM_CONST(0x1d) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y10___U10V10_N444 _MK_ENUM_CONST(0x1e) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y10___V10U10_N444 _MK_ENUM_CONST(0x1f) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y12___U12V12_N444 _MK_ENUM_CONST(0x20) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y12___V12U12_N444 _MK_ENUM_CONST(0x21) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y16___U16V16_N444 _MK_ENUM_CONST(0x22) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_FORMAT_T_Y16___V16U16_N444 _MK_ENUM_CONST(0x23) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_FIELD _MK_FIELD_CONST(0x1, CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_SHIFT) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_PITCH_LINEAR _MK_ENUM_CONST(0x0) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_MAPPING_RESERVED_LINEAR _MK_ENUM_CONST(0x1) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SHIFT _MK_SHIFT_CONST(20) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_FIELD _MK_FIELD_CONST(0x1, CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SHIFT) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_UNSIGNED_INT _MK_ENUM_CONST(0x0) +#define CDMA_D_DATAIN_FORMAT_0_PIXEL_SIGN_OVERRIDE_SIGNED_INT _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_DATAIN_SIZE_0_0 +#define CDMA_D_DATAIN_SIZE_0_0 _MK_ADDR_CONST(0x301c) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, CDMA_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, CDMA_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT) + + +// Register CDMA_D_DATAIN_SIZE_1_0 +#define CDMA_D_DATAIN_SIZE_1_0 _MK_ADDR_CONST(0x3020) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, CDMA_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT) + + +// Register CDMA_D_DATAIN_SIZE_EXT_0_0 +#define CDMA_D_DATAIN_SIZE_EXT_0_0 _MK_ADDR_CONST(0x3024) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_FIELD _MK_FIELD_CONST(0x1fff, CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_FIELD _MK_FIELD_CONST(0x1fff, CDMA_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT) + + +// Register CDMA_D_PIXEL_OFFSET_0 +#define CDMA_D_PIXEL_OFFSET_0 _MK_ADDR_CONST(0x3028) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_FIELD _MK_FIELD_CONST(0x1f, CDMA_D_PIXEL_OFFSET_0_PIXEL_X_OFFSET_SHIFT) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_FIELD _MK_FIELD_CONST(0x7, CDMA_D_PIXEL_OFFSET_0_PIXEL_Y_OFFSET_SHIFT) + + +// Register CDMA_D_DAIN_RAM_TYPE_0 +#define CDMA_D_DAIN_RAM_TYPE_0 _MK_ADDR_CONST(0x302c) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_CVIF _MK_ENUM_CONST(0x0) +#define CDMA_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_MCIF _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_DAIN_ADDR_HIGH_0_0 +#define CDMA_D_DAIN_ADDR_HIGH_0_0 _MK_ADDR_CONST(0x3030) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_DAIN_ADDR_HIGH_0_0_DATAIN_ADDR_HIGH_0_SHIFT) + + +// Register CDMA_D_DAIN_ADDR_LOW_0_0 +#define CDMA_D_DAIN_ADDR_LOW_0_0 _MK_ADDR_CONST(0x3034) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_DAIN_ADDR_LOW_0_0_DATAIN_ADDR_LOW_0_SHIFT) + + +// Register CDMA_D_DAIN_ADDR_HIGH_1_0 +#define CDMA_D_DAIN_ADDR_HIGH_1_0 _MK_ADDR_CONST(0x3038) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_DAIN_ADDR_HIGH_1_0_DATAIN_ADDR_HIGH_1_SHIFT) + + +// Register CDMA_D_DAIN_ADDR_LOW_1_0 +#define CDMA_D_DAIN_ADDR_LOW_1_0 _MK_ADDR_CONST(0x303c) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_DAIN_ADDR_LOW_1_0_DATAIN_ADDR_LOW_1_SHIFT) + + +// Register CDMA_D_LINE_STRIDE_0 +#define CDMA_D_LINE_STRIDE_0 _MK_ADDR_CONST(0x3040) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_LINE_STRIDE_0_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT) + + +// Register CDMA_D_LINE_UV_STRIDE_0 +#define CDMA_D_LINE_UV_STRIDE_0 _MK_ADDR_CONST(0x3044) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_LINE_UV_STRIDE_0_UV_LINE_STRIDE_SHIFT) + + +// Register CDMA_D_SURF_STRIDE_0 +#define CDMA_D_SURF_STRIDE_0 _MK_ADDR_CONST(0x3048) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_SURF_STRIDE_0_SURF_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT) + + +// Register CDMA_D_DAIN_MAP_0 +#define CDMA_D_DAIN_MAP_0 _MK_ADDR_CONST(0x304c) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_FIELD _MK_FIELD_CONST(0x1, CDMA_D_DAIN_MAP_0_LINE_PACKED_SHIFT) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_FALSE _MK_ENUM_CONST(0x0) +#define CDMA_D_DAIN_MAP_0_LINE_PACKED_TRUE _MK_ENUM_CONST(0x1) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_FIELD _MK_FIELD_CONST(0x1, CDMA_D_DAIN_MAP_0_SURF_PACKED_SHIFT) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_FALSE _MK_ENUM_CONST(0x0) +#define CDMA_D_DAIN_MAP_0_SURF_PACKED_TRUE _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_RESERVED_X_CFG_0 +#define CDMA_D_RESERVED_X_CFG_0 _MK_ADDR_CONST(0x3050) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_FIELD _MK_FIELD_CONST(0x3ff, CDMA_D_RESERVED_X_CFG_0_RSV_PER_LINE_SHIFT) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_FIELD _MK_FIELD_CONST(0x3ff, CDMA_D_RESERVED_X_CFG_0_RSV_PER_UV_LINE_SHIFT) + + +// Register CDMA_D_RESERVED_Y_CFG_0 +#define CDMA_D_RESERVED_Y_CFG_0 _MK_ADDR_CONST(0x3054) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_FIELD _MK_FIELD_CONST(0x7, CDMA_D_RESERVED_Y_CFG_0_RSV_HEIGHT_SHIFT) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_FIELD _MK_FIELD_CONST(0x1f, CDMA_D_RESERVED_Y_CFG_0_RSV_Y_INDEX_SHIFT) + + +// Register CDMA_D_BATCH_NUMBER_0 +#define CDMA_D_BATCH_NUMBER_0 _MK_ADDR_CONST(0x3058) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_BATCH_NUMBER_0_BATCHES_FIELD _MK_FIELD_CONST(0x1f, CDMA_D_BATCH_NUMBER_0_BATCHES_SHIFT) + + +// Register CDMA_D_BATCH_STRIDE_0 +#define CDMA_D_BATCH_STRIDE_0 _MK_ADDR_CONST(0x305c) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_BATCH_STRIDE_0_BATCH_STRIDE_SHIFT) + + +// Register CDMA_D_ENTRY_PER_SLICE_0 +#define CDMA_D_ENTRY_PER_SLICE_0 _MK_ADDR_CONST(0x3060) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_FIELD _MK_FIELD_CONST(0x3fff, CDMA_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT) + + +// Register CDMA_D_FETCH_GRAIN_0 +#define CDMA_D_FETCH_GRAIN_0 _MK_ADDR_CONST(0x3064) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_FETCH_GRAIN_0_GRAINS_FIELD _MK_FIELD_CONST(0xfff, CDMA_D_FETCH_GRAIN_0_GRAINS_SHIFT) + + +// Register CDMA_D_WEIGHT_FORMAT_0 +#define CDMA_D_WEIGHT_FORMAT_0 _MK_ADDR_CONST(0x3068) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_FIELD _MK_FIELD_CONST(0x1, CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_UNCOMPRESSED _MK_ENUM_CONST(0x0) +#define CDMA_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_COMPRESSED _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_WEIGHT_SIZE_0_0 +#define CDMA_D_WEIGHT_SIZE_0_0 _MK_ADDR_CONST(0x306c) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_FIELD _MK_FIELD_CONST(0x3ffff, CDMA_D_WEIGHT_SIZE_0_0_BYTE_PER_KERNEL_SHIFT) + + +// Register CDMA_D_WEIGHT_SIZE_1_0 +#define CDMA_D_WEIGHT_SIZE_1_0 _MK_ADDR_CONST(0x3070) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_FIELD _MK_FIELD_CONST(0x1fff, CDMA_D_WEIGHT_SIZE_1_0_WEIGHT_KERNEL_SHIFT) + + +// Register CDMA_D_WEIGHT_RAM_TYPE_0 +#define CDMA_D_WEIGHT_RAM_TYPE_0 _MK_ADDR_CONST(0x3074) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_SHIFT) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_CVIF _MK_ENUM_CONST(0x0) +#define CDMA_D_WEIGHT_RAM_TYPE_0_WEIGHT_RAM_TYPE_MCIF _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_WEIGHT_ADDR_HIGH_0 +#define CDMA_D_WEIGHT_ADDR_HIGH_0 _MK_ADDR_CONST(0x3078) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_WEIGHT_ADDR_HIGH_0_WEIGHT_ADDR_HIGH_SHIFT) + + +// Register CDMA_D_WEIGHT_ADDR_LOW_0 +#define CDMA_D_WEIGHT_ADDR_LOW_0 _MK_ADDR_CONST(0x307c) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_WEIGHT_ADDR_LOW_0_WEIGHT_ADDR_LOW_SHIFT) + + +// Register CDMA_D_WEIGHT_BYTES_0 +#define CDMA_D_WEIGHT_BYTES_0 _MK_ADDR_CONST(0x3080) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT) + + +// Register CDMA_D_WGS_ADDR_HIGH_0 +#define CDMA_D_WGS_ADDR_HIGH_0 _MK_ADDR_CONST(0x3084) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_WGS_ADDR_HIGH_0_WGS_ADDR_HIGH_SHIFT) + + +// Register CDMA_D_WGS_ADDR_LOW_0 +#define CDMA_D_WGS_ADDR_LOW_0 _MK_ADDR_CONST(0x3088) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_WGS_ADDR_LOW_0_WGS_ADDR_LOW_SHIFT) + + +// Register CDMA_D_WMB_ADDR_HIGH_0 +#define CDMA_D_WMB_ADDR_HIGH_0 _MK_ADDR_CONST(0x308c) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_WMB_ADDR_HIGH_0_WMB_ADDR_HIGH_SHIFT) + + +// Register CDMA_D_WMB_ADDR_LOW_0 +#define CDMA_D_WMB_ADDR_LOW_0 _MK_ADDR_CONST(0x3090) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_WMB_ADDR_LOW_0_WMB_ADDR_LOW_SHIFT) + + +// Register CDMA_D_WMB_BYTES_0 +#define CDMA_D_WMB_BYTES_0 _MK_ADDR_CONST(0x3094) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_WMB_BYTES_0_WMB_BYTES_FIELD _MK_FIELD_CONST(0xfffffff, CDMA_D_WMB_BYTES_0_WMB_BYTES_SHIFT) + + +// Register CDMA_D_MEAN_FORMAT_0 +#define CDMA_D_MEAN_FORMAT_0 _MK_ADDR_CONST(0x3098) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_FIELD _MK_FIELD_CONST(0x1, CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_SHIFT) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_MEAN_FORMAT_0_MEAN_FORMAT_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_MEAN_GLOBAL_0_0 +#define CDMA_D_MEAN_GLOBAL_0_0 _MK_ADDR_CONST(0x309c) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_FIELD _MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_0_0_MEAN_RY_SHIFT) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_FIELD _MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_0_0_MEAN_GU_SHIFT) + + +// Register CDMA_D_MEAN_GLOBAL_1_0 +#define CDMA_D_MEAN_GLOBAL_1_0 _MK_ADDR_CONST(0x30a0) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_FIELD _MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_1_0_MEAN_BV_SHIFT) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_FIELD _MK_FIELD_CONST(0xffff, CDMA_D_MEAN_GLOBAL_1_0_MEAN_AX_SHIFT) + + +// Register CDMA_D_CVT_CFG_0 +#define CDMA_D_CVT_CFG_0 _MK_ADDR_CONST(0x30a4) +#define CDMA_D_CVT_CFG_0_CVT_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_CVT_CFG_0_CVT_EN_FIELD _MK_FIELD_CONST(0x1, CDMA_D_CVT_CFG_0_CVT_EN_SHIFT) +#define CDMA_D_CVT_CFG_0_CVT_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_CVT_CFG_0_CVT_EN_ENABLE _MK_ENUM_CONST(0x1) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_SHIFT _MK_SHIFT_CONST(4) +#define CDMA_D_CVT_CFG_0_CVT_TRUNCATE_FIELD _MK_FIELD_CONST(0x3f, CDMA_D_CVT_CFG_0_CVT_TRUNCATE_SHIFT) + + +// Register CDMA_D_CVT_OFFSET_0 +#define CDMA_D_CVT_OFFSET_0 _MK_ADDR_CONST(0x30a8) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_CVT_OFFSET_0_CVT_OFFSET_FIELD _MK_FIELD_CONST(0xffff, CDMA_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT) + + +// Register CDMA_D_CVT_SCALE_0 +#define CDMA_D_CVT_SCALE_0 _MK_ADDR_CONST(0x30ac) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_CVT_SCALE_0_CVT_SCALE_FIELD _MK_FIELD_CONST(0xffff, CDMA_D_CVT_SCALE_0_CVT_SCALE_SHIFT) + + +// Register CDMA_D_CONV_STRIDE_0 +#define CDMA_D_CONV_STRIDE_0 _MK_ADDR_CONST(0x30b0) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_FIELD _MK_FIELD_CONST(0x7, CDMA_D_CONV_STRIDE_0_CONV_X_STRIDE_SHIFT) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_FIELD _MK_FIELD_CONST(0x7, CDMA_D_CONV_STRIDE_0_CONV_Y_STRIDE_SHIFT) + + +// Register CDMA_D_ZERO_PADDING_0 +#define CDMA_D_ZERO_PADDING_0 _MK_ADDR_CONST(0x30b4) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_ZERO_PADDING_0_PAD_LEFT_FIELD _MK_FIELD_CONST(0x1f, CDMA_D_ZERO_PADDING_0_PAD_LEFT_SHIFT) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_SHIFT _MK_SHIFT_CONST(8) +#define CDMA_D_ZERO_PADDING_0_PAD_RIGHT_FIELD _MK_FIELD_CONST(0x3f, CDMA_D_ZERO_PADDING_0_PAD_RIGHT_SHIFT) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_ZERO_PADDING_0_PAD_TOP_FIELD _MK_FIELD_CONST(0x1f, CDMA_D_ZERO_PADDING_0_PAD_TOP_SHIFT) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_SHIFT _MK_SHIFT_CONST(24) +#define CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_FIELD _MK_FIELD_CONST(0x3f, CDMA_D_ZERO_PADDING_0_PAD_BOTTOM_SHIFT) + + +// Register CDMA_D_ZERO_PADDING_VALUE_0 +#define CDMA_D_ZERO_PADDING_VALUE_0 _MK_ADDR_CONST(0x30b8) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_FIELD _MK_FIELD_CONST(0xffff, CDMA_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT) + + +// Register CDMA_D_BANK_0 +#define CDMA_D_BANK_0 _MK_ADDR_CONST(0x30bc) +#define CDMA_D_BANK_0_DATA_BANK_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_BANK_0_DATA_BANK_FIELD _MK_FIELD_CONST(0x1f, CDMA_D_BANK_0_DATA_BANK_SHIFT) +#define CDMA_D_BANK_0_WEIGHT_BANK_SHIFT _MK_SHIFT_CONST(16) +#define CDMA_D_BANK_0_WEIGHT_BANK_FIELD _MK_FIELD_CONST(0x1f, CDMA_D_BANK_0_WEIGHT_BANK_SHIFT) + + +// Register CDMA_D_NAN_FLUSH_TO_ZERO_0 +#define CDMA_D_NAN_FLUSH_TO_ZERO_0 _MK_ADDR_CONST(0x30c0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_FIELD _MK_FIELD_CONST(0x1, CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DISABLE _MK_ENUM_CONST(0x0) +#define CDMA_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDMA_D_NAN_INPUT_DATA_NUM_0 +#define CDMA_D_NAN_INPUT_DATA_NUM_0 _MK_ADDR_CONST(0x30c4) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_NAN_INPUT_DATA_NUM_0_NAN_DATA_NUM_SHIFT) + + +// Register CDMA_D_NAN_INPUT_WEIGHT_NUM_0 +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0 _MK_ADDR_CONST(0x30c8) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_NAN_INPUT_WEIGHT_NUM_0_NAN_WEIGHT_NUM_SHIFT) + + +// Register CDMA_D_INF_INPUT_DATA_NUM_0 +#define CDMA_D_INF_INPUT_DATA_NUM_0 _MK_ADDR_CONST(0x30cc) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_INF_INPUT_DATA_NUM_0_INF_DATA_NUM_SHIFT) + + +// Register CDMA_D_INF_INPUT_WEIGHT_NUM_0 +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0 _MK_ADDR_CONST(0x30d0) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_INF_INPUT_WEIGHT_NUM_0_INF_WEIGHT_NUM_SHIFT) + + +// Register CDMA_D_PERF_ENABLE_0 +#define CDMA_D_PERF_ENABLE_0 _MK_ADDR_CONST(0x30d4) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_PERF_ENABLE_0_DMA_EN_FIELD _MK_FIELD_CONST(0x1, CDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT) + + +// Register CDMA_D_PERF_DAT_READ_STALL_0 +#define CDMA_D_PERF_DAT_READ_STALL_0 _MK_ADDR_CONST(0x30d8) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_PERF_DAT_READ_STALL_0_DAT_RD_STALL_SHIFT) + + +// Register CDMA_D_PERF_WT_READ_STALL_0 +#define CDMA_D_PERF_WT_READ_STALL_0 _MK_ADDR_CONST(0x30dc) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_PERF_WT_READ_STALL_0_WT_RD_STALL_SHIFT) + + +// Register CDMA_D_PERF_DAT_READ_LATENCY_0 +#define CDMA_D_PERF_DAT_READ_LATENCY_0 _MK_ADDR_CONST(0x30e0) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_PERF_DAT_READ_LATENCY_0_DAT_RD_LATENCY_SHIFT) + + +// Register CDMA_D_PERF_WT_READ_LATENCY_0 +#define CDMA_D_PERF_WT_READ_LATENCY_0 _MK_ADDR_CONST(0x30e4) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_PERF_WT_READ_LATENCY_0_WT_RD_LATENCY_SHIFT) + + +// Register CDMA_D_CYA_0 +#define CDMA_D_CYA_0 _MK_ADDR_CONST(0x30e8) +#define CDMA_D_CYA_0_CYA_SHIFT _MK_SHIFT_CONST(0) +#define CDMA_D_CYA_0_CYA_FIELD _MK_FIELD_CONST(0xffffffff, CDMA_D_CYA_0_CYA_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register CSC_S_STATUS_0 +#define CSC_S_STATUS_0 _MK_ADDR_CONST(0x4000) +#define CSC_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define CSC_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, CSC_S_STATUS_0_STATUS_0_SHIFT) +#define CSC_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define CSC_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define CSC_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define CSC_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define CSC_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, CSC_S_STATUS_0_STATUS_1_SHIFT) +#define CSC_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define CSC_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define CSC_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register CSC_S_POINTER_0 +#define CSC_S_POINTER_0 _MK_ADDR_CONST(0x4004) +#define CSC_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define CSC_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, CSC_S_POINTER_0_PRODUCER_SHIFT) +#define CSC_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CSC_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define CSC_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define CSC_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, CSC_S_POINTER_0_CONSUMER_SHIFT) +#define CSC_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CSC_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register CSC_D_OP_ENABLE_0 +#define CSC_D_OP_ENABLE_0 _MK_ADDR_CONST(0x4008) +#define CSC_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, CSC_D_OP_ENABLE_0_OP_EN_SHIFT) +#define CSC_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CSC_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CSC_D_MISC_CFG_0 +#define CSC_D_MISC_CFG_0 _MK_ADDR_CONST(0x400c) +#define CSC_D_MISC_CFG_0_CONV_MODE_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_MISC_CFG_0_CONV_MODE_FIELD _MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_CONV_MODE_SHIFT) +#define CSC_D_MISC_CFG_0_CONV_MODE_DIRECT _MK_ENUM_CONST(0x0) +#define CSC_D_MISC_CFG_0_CONV_MODE_WINOGRAD _MK_ENUM_CONST(0x1) +#define CSC_D_MISC_CFG_0_IN_PRECISION_SHIFT _MK_SHIFT_CONST(8) +#define CSC_D_MISC_CFG_0_IN_PRECISION_FIELD _MK_FIELD_CONST(0x3, CSC_D_MISC_CFG_0_IN_PRECISION_SHIFT) +#define CSC_D_MISC_CFG_0_IN_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define CSC_D_MISC_CFG_0_IN_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define CSC_D_MISC_CFG_0_IN_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_SHIFT _MK_SHIFT_CONST(12) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_FIELD _MK_FIELD_CONST(0x3, CSC_D_MISC_CFG_0_PROC_PRECISION_SHIFT) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define CSC_D_MISC_CFG_0_PROC_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define CSC_D_MISC_CFG_0_DATA_REUSE_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_MISC_CFG_0_DATA_REUSE_FIELD _MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_DATA_REUSE_SHIFT) +#define CSC_D_MISC_CFG_0_DATA_REUSE_DISABLE _MK_ENUM_CONST(0x0) +#define CSC_D_MISC_CFG_0_DATA_REUSE_ENABLE _MK_ENUM_CONST(0x1) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT _MK_SHIFT_CONST(20) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_FIELD _MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_WEIGHT_REUSE_SHIFT) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_DISABLE _MK_ENUM_CONST(0x0) +#define CSC_D_MISC_CFG_0_WEIGHT_REUSE_ENABLE _MK_ENUM_CONST(0x1) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT _MK_SHIFT_CONST(24) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_FIELD _MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_SKIP_DATA_RLS_SHIFT) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_DISABLE _MK_ENUM_CONST(0x0) +#define CSC_D_MISC_CFG_0_SKIP_DATA_RLS_ENABLE _MK_ENUM_CONST(0x1) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT _MK_SHIFT_CONST(28) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_FIELD _MK_FIELD_CONST(0x1, CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_SHIFT) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_DISABLE _MK_ENUM_CONST(0x0) +#define CSC_D_MISC_CFG_0_SKIP_WEIGHT_RLS_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CSC_D_DATAIN_FORMAT_0 +#define CSC_D_DATAIN_FORMAT_0 _MK_ADDR_CONST(0x4010) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FIELD _MK_FIELD_CONST(0x1, CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_SHIFT) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_FEATURE _MK_ENUM_CONST(0x0) +#define CSC_D_DATAIN_FORMAT_0_DATAIN_FORMAT_PIXEL _MK_ENUM_CONST(0x1) + + +// Register CSC_D_DATAIN_SIZE_EXT_0_0 +#define CSC_D_DATAIN_SIZE_EXT_0_0 _MK_ADDR_CONST(0x4014) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_WIDTH_EXT_SHIFT) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_DATAIN_SIZE_EXT_0_0_DATAIN_HEIGHT_EXT_SHIFT) + + +// Register CSC_D_DATAIN_SIZE_EXT_1_0 +#define CSC_D_DATAIN_SIZE_EXT_1_0 _MK_ADDR_CONST(0x4018) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_DATAIN_SIZE_EXT_1_0_DATAIN_CHANNEL_EXT_SHIFT) + + +// Register CSC_D_BATCH_NUMBER_0 +#define CSC_D_BATCH_NUMBER_0 _MK_ADDR_CONST(0x401c) +#define CSC_D_BATCH_NUMBER_0_BATCHES_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_BATCH_NUMBER_0_BATCHES_FIELD _MK_FIELD_CONST(0x1f, CSC_D_BATCH_NUMBER_0_BATCHES_SHIFT) + + +// Register CSC_D_POST_Y_EXTENSION_0 +#define CSC_D_POST_Y_EXTENSION_0 _MK_ADDR_CONST(0x4020) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_FIELD _MK_FIELD_CONST(0x3, CSC_D_POST_Y_EXTENSION_0_Y_EXTENSION_SHIFT) + + +// Register CSC_D_ENTRY_PER_SLICE_0 +#define CSC_D_ENTRY_PER_SLICE_0 _MK_ADDR_CONST(0x4024) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_ENTRY_PER_SLICE_0_ENTRIES_FIELD _MK_FIELD_CONST(0x3fff, CSC_D_ENTRY_PER_SLICE_0_ENTRIES_SHIFT) + + +// Register CSC_D_WEIGHT_FORMAT_0 +#define CSC_D_WEIGHT_FORMAT_0 _MK_ADDR_CONST(0x4028) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_FIELD _MK_FIELD_CONST(0x1, CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_SHIFT) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_UNCOMPRESSED _MK_ENUM_CONST(0x0) +#define CSC_D_WEIGHT_FORMAT_0_WEIGHT_FORMAT_COMPRESSED _MK_ENUM_CONST(0x1) + + +// Register CSC_D_WEIGHT_SIZE_EXT_0_0 +#define CSC_D_WEIGHT_SIZE_EXT_0_0 _MK_ADDR_CONST(0x402c) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_FIELD _MK_FIELD_CONST(0x1f, CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_WIDTH_EXT_SHIFT) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_FIELD _MK_FIELD_CONST(0x1f, CSC_D_WEIGHT_SIZE_EXT_0_0_WEIGHT_HEIGHT_EXT_SHIFT) + + +// Register CSC_D_WEIGHT_SIZE_EXT_1_0 +#define CSC_D_WEIGHT_SIZE_EXT_1_0 _MK_ADDR_CONST(0x4030) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_CHANNEL_EXT_SHIFT) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_WEIGHT_SIZE_EXT_1_0_WEIGHT_KERNEL_SHIFT) + + +// Register CSC_D_WEIGHT_BYTES_0 +#define CSC_D_WEIGHT_BYTES_0 _MK_ADDR_CONST(0x4034) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_FIELD _MK_FIELD_CONST(0xffffffff, CSC_D_WEIGHT_BYTES_0_WEIGHT_BYTES_SHIFT) + + +// Register CSC_D_WMB_BYTES_0 +#define CSC_D_WMB_BYTES_0 _MK_ADDR_CONST(0x4038) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_WMB_BYTES_0_WMB_BYTES_FIELD _MK_FIELD_CONST(0xfffffff, CSC_D_WMB_BYTES_0_WMB_BYTES_SHIFT) + + +// Register CSC_D_DATAOUT_SIZE_0_0 +#define CSC_D_DATAOUT_SIZE_0_0 _MK_ADDR_CONST(0x403c) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT) + + +// Register CSC_D_DATAOUT_SIZE_1_0 +#define CSC_D_DATAOUT_SIZE_1_0 _MK_ADDR_CONST(0x4040) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, CSC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT) + + +// Register CSC_D_ATOMICS_0 +#define CSC_D_ATOMICS_0 _MK_ADDR_CONST(0x4044) +#define CSC_D_ATOMICS_0_ATOMICS_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_ATOMICS_0_ATOMICS_FIELD _MK_FIELD_CONST(0x1fffff, CSC_D_ATOMICS_0_ATOMICS_SHIFT) + + +// Register CSC_D_RELEASE_0 +#define CSC_D_RELEASE_0 _MK_ADDR_CONST(0x4048) +#define CSC_D_RELEASE_0_RLS_SLICES_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_RELEASE_0_RLS_SLICES_FIELD _MK_FIELD_CONST(0xfff, CSC_D_RELEASE_0_RLS_SLICES_SHIFT) + + +// Register CSC_D_CONV_STRIDE_EXT_0 +#define CSC_D_CONV_STRIDE_EXT_0 _MK_ADDR_CONST(0x404c) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_FIELD _MK_FIELD_CONST(0x7, CSC_D_CONV_STRIDE_EXT_0_CONV_X_STRIDE_EXT_SHIFT) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_FIELD _MK_FIELD_CONST(0x7, CSC_D_CONV_STRIDE_EXT_0_CONV_Y_STRIDE_EXT_SHIFT) + + +// Register CSC_D_DILATION_EXT_0 +#define CSC_D_DILATION_EXT_0 _MK_ADDR_CONST(0x4050) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_DILATION_EXT_0_X_DILATION_EXT_FIELD _MK_FIELD_CONST(0x1f, CSC_D_DILATION_EXT_0_X_DILATION_EXT_SHIFT) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_DILATION_EXT_0_Y_DILATION_EXT_FIELD _MK_FIELD_CONST(0x1f, CSC_D_DILATION_EXT_0_Y_DILATION_EXT_SHIFT) + + +// Register CSC_D_ZERO_PADDING_0 +#define CSC_D_ZERO_PADDING_0 _MK_ADDR_CONST(0x4054) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_ZERO_PADDING_0_PAD_LEFT_FIELD _MK_FIELD_CONST(0x1f, CSC_D_ZERO_PADDING_0_PAD_LEFT_SHIFT) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_ZERO_PADDING_0_PAD_TOP_FIELD _MK_FIELD_CONST(0x1f, CSC_D_ZERO_PADDING_0_PAD_TOP_SHIFT) + + +// Register CSC_D_ZERO_PADDING_VALUE_0 +#define CSC_D_ZERO_PADDING_VALUE_0 _MK_ADDR_CONST(0x4058) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_FIELD _MK_FIELD_CONST(0xffff, CSC_D_ZERO_PADDING_VALUE_0_PAD_VALUE_SHIFT) + + +// Register CSC_D_BANK_0 +#define CSC_D_BANK_0 _MK_ADDR_CONST(0x405c) +#define CSC_D_BANK_0_DATA_BANK_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_BANK_0_DATA_BANK_FIELD _MK_FIELD_CONST(0x1f, CSC_D_BANK_0_DATA_BANK_SHIFT) +#define CSC_D_BANK_0_WEIGHT_BANK_SHIFT _MK_SHIFT_CONST(16) +#define CSC_D_BANK_0_WEIGHT_BANK_FIELD _MK_FIELD_CONST(0x1f, CSC_D_BANK_0_WEIGHT_BANK_SHIFT) + + +// Register CSC_D_PRA_CFG_0 +#define CSC_D_PRA_CFG_0 _MK_ADDR_CONST(0x4060) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_PRA_CFG_0_PRA_TRUNCATE_FIELD _MK_FIELD_CONST(0x3, CSC_D_PRA_CFG_0_PRA_TRUNCATE_SHIFT) + + +// Register CSC_D_CYA_0 +#define CSC_D_CYA_0 _MK_ADDR_CONST(0x4064) +#define CSC_D_CYA_0_CYA_SHIFT _MK_SHIFT_CONST(0) +#define CSC_D_CYA_0_CYA_FIELD _MK_FIELD_CONST(0xffffffff, CSC_D_CYA_0_CYA_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register CMAC_A_S_STATUS_0 +#define CMAC_A_S_STATUS_0 _MK_ADDR_CONST(0x5000) +#define CMAC_A_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_A_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, CMAC_A_S_STATUS_0_STATUS_0_SHIFT) +#define CMAC_A_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define CMAC_A_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define CMAC_A_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define CMAC_A_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define CMAC_A_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, CMAC_A_S_STATUS_0_STATUS_1_SHIFT) +#define CMAC_A_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define CMAC_A_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define CMAC_A_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register CMAC_A_S_POINTER_0 +#define CMAC_A_S_POINTER_0 _MK_ADDR_CONST(0x5004) +#define CMAC_A_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_A_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, CMAC_A_S_POINTER_0_PRODUCER_SHIFT) +#define CMAC_A_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CMAC_A_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define CMAC_A_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define CMAC_A_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, CMAC_A_S_POINTER_0_CONSUMER_SHIFT) +#define CMAC_A_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CMAC_A_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register CMAC_A_D_OP_ENABLE_0 +#define CMAC_A_D_OP_ENABLE_0 _MK_ADDR_CONST(0x5008) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, CMAC_A_D_OP_ENABLE_0_OP_EN_SHIFT) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CMAC_A_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CMAC_A_D_MISC_CFG_0 +#define CMAC_A_D_MISC_CFG_0 _MK_ADDR_CONST(0x500c) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_FIELD _MK_FIELD_CONST(0x1, CMAC_A_D_MISC_CFG_0_CONV_MODE_SHIFT) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_DIRECT _MK_ENUM_CONST(0x0) +#define CMAC_A_D_MISC_CFG_0_CONV_MODE_WINOGRAD _MK_ENUM_CONST(0x1) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_SHIFT _MK_SHIFT_CONST(12) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_FIELD _MK_FIELD_CONST(0x3, CMAC_A_D_MISC_CFG_0_PROC_PRECISION_SHIFT) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define CMAC_A_D_MISC_CFG_0_PROC_PRECISION_FP16 _MK_ENUM_CONST(0x2) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register CMAC_B_S_STATUS_0 +#define CMAC_B_S_STATUS_0 _MK_ADDR_CONST(0x6000) +#define CMAC_B_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_B_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, CMAC_B_S_STATUS_0_STATUS_0_SHIFT) +#define CMAC_B_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define CMAC_B_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define CMAC_B_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define CMAC_B_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define CMAC_B_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, CMAC_B_S_STATUS_0_STATUS_1_SHIFT) +#define CMAC_B_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define CMAC_B_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define CMAC_B_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register CMAC_B_S_POINTER_0 +#define CMAC_B_S_POINTER_0 _MK_ADDR_CONST(0x6004) +#define CMAC_B_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_B_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, CMAC_B_S_POINTER_0_PRODUCER_SHIFT) +#define CMAC_B_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CMAC_B_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define CMAC_B_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define CMAC_B_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, CMAC_B_S_POINTER_0_CONSUMER_SHIFT) +#define CMAC_B_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CMAC_B_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register CMAC_B_D_OP_ENABLE_0 +#define CMAC_B_D_OP_ENABLE_0 _MK_ADDR_CONST(0x6008) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, CMAC_B_D_OP_ENABLE_0_OP_EN_SHIFT) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CMAC_B_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CMAC_B_D_MISC_CFG_0 +#define CMAC_B_D_MISC_CFG_0 _MK_ADDR_CONST(0x600c) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_SHIFT _MK_SHIFT_CONST(0) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_FIELD _MK_FIELD_CONST(0x1, CMAC_B_D_MISC_CFG_0_CONV_MODE_SHIFT) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_DIRECT _MK_ENUM_CONST(0x0) +#define CMAC_B_D_MISC_CFG_0_CONV_MODE_WINOGRAD _MK_ENUM_CONST(0x1) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_SHIFT _MK_SHIFT_CONST(12) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_FIELD _MK_FIELD_CONST(0x3, CMAC_B_D_MISC_CFG_0_PROC_PRECISION_SHIFT) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define CMAC_B_D_MISC_CFG_0_PROC_PRECISION_FP16 _MK_ENUM_CONST(0x2) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register CACC_S_STATUS_0 +#define CACC_S_STATUS_0 _MK_ADDR_CONST(0x7000) +#define CACC_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define CACC_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, CACC_S_STATUS_0_STATUS_0_SHIFT) +#define CACC_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define CACC_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define CACC_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define CACC_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define CACC_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, CACC_S_STATUS_0_STATUS_1_SHIFT) +#define CACC_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define CACC_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define CACC_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register CACC_S_POINTER_0 +#define CACC_S_POINTER_0 _MK_ADDR_CONST(0x7004) +#define CACC_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define CACC_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, CACC_S_POINTER_0_PRODUCER_SHIFT) +#define CACC_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CACC_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define CACC_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define CACC_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, CACC_S_POINTER_0_CONSUMER_SHIFT) +#define CACC_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CACC_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register CACC_D_OP_ENABLE_0 +#define CACC_D_OP_ENABLE_0 _MK_ADDR_CONST(0x7008) +#define CACC_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, CACC_D_OP_ENABLE_0_OP_EN_SHIFT) +#define CACC_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CACC_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CACC_D_MISC_CFG_0 +#define CACC_D_MISC_CFG_0 _MK_ADDR_CONST(0x700c) +#define CACC_D_MISC_CFG_0_CONV_MODE_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_MISC_CFG_0_CONV_MODE_FIELD _MK_FIELD_CONST(0x1, CACC_D_MISC_CFG_0_CONV_MODE_SHIFT) +#define CACC_D_MISC_CFG_0_CONV_MODE_DIRECT _MK_ENUM_CONST(0x0) +#define CACC_D_MISC_CFG_0_CONV_MODE_WINOGRAD _MK_ENUM_CONST(0x1) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_SHIFT _MK_SHIFT_CONST(12) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_FIELD _MK_FIELD_CONST(0x3, CACC_D_MISC_CFG_0_PROC_PRECISION_SHIFT) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define CACC_D_MISC_CFG_0_PROC_PRECISION_FP16 _MK_ENUM_CONST(0x2) + + +// Register CACC_D_DATAOUT_SIZE_0_0 +#define CACC_D_DATAOUT_SIZE_0_0 _MK_ADDR_CONST(0x7010) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, CACC_D_DATAOUT_SIZE_0_0_DATAOUT_WIDTH_SHIFT) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT _MK_SHIFT_CONST(16) +#define CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, CACC_D_DATAOUT_SIZE_0_0_DATAOUT_HEIGHT_SHIFT) + + +// Register CACC_D_DATAOUT_SIZE_1_0 +#define CACC_D_DATAOUT_SIZE_1_0 _MK_ADDR_CONST(0x7014) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, CACC_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT) + + +// Register CACC_D_DATAOUT_ADDR_0 +#define CACC_D_DATAOUT_ADDR_0 _MK_ADDR_CONST(0x7018) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_FIELD _MK_FIELD_CONST(0xffffffff, CACC_D_DATAOUT_ADDR_0_DATAOUT_ADDR_SHIFT) + + +// Register CACC_D_BATCH_NUMBER_0 +#define CACC_D_BATCH_NUMBER_0 _MK_ADDR_CONST(0x701c) +#define CACC_D_BATCH_NUMBER_0_BATCHES_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_BATCH_NUMBER_0_BATCHES_FIELD _MK_FIELD_CONST(0x1f, CACC_D_BATCH_NUMBER_0_BATCHES_SHIFT) + + +// Register CACC_D_LINE_STRIDE_0 +#define CACC_D_LINE_STRIDE_0 _MK_ADDR_CONST(0x7020) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_LINE_STRIDE_0_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffff, CACC_D_LINE_STRIDE_0_LINE_STRIDE_SHIFT) + + +// Register CACC_D_SURF_STRIDE_0 +#define CACC_D_SURF_STRIDE_0 _MK_ADDR_CONST(0x7024) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_SURF_STRIDE_0_SURF_STRIDE_FIELD _MK_FIELD_CONST(0xffffff, CACC_D_SURF_STRIDE_0_SURF_STRIDE_SHIFT) + + +// Register CACC_D_DATAOUT_MAP_0 +#define CACC_D_DATAOUT_MAP_0 _MK_ADDR_CONST(0x7028) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_FIELD _MK_FIELD_CONST(0x1, CACC_D_DATAOUT_MAP_0_LINE_PACKED_SHIFT) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_FALSE _MK_ENUM_CONST(0x0) +#define CACC_D_DATAOUT_MAP_0_LINE_PACKED_TRUE _MK_ENUM_CONST(0x1) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_SHIFT _MK_SHIFT_CONST(16) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_FIELD _MK_FIELD_CONST(0x1, CACC_D_DATAOUT_MAP_0_SURF_PACKED_SHIFT) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_FALSE _MK_ENUM_CONST(0x0) +#define CACC_D_DATAOUT_MAP_0_SURF_PACKED_TRUE _MK_ENUM_CONST(0x1) + + +// Register CACC_D_CLIP_CFG_0 +#define CACC_D_CLIP_CFG_0 _MK_ADDR_CONST(0x702c) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_FIELD _MK_FIELD_CONST(0x1f, CACC_D_CLIP_CFG_0_CLIP_TRUNCATE_SHIFT) + + +// Register CACC_D_OUT_SATURATION_0 +#define CACC_D_OUT_SATURATION_0 _MK_ADDR_CONST(0x7030) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_OUT_SATURATION_0_SAT_COUNT_FIELD _MK_FIELD_CONST(0xffffffff, CACC_D_OUT_SATURATION_0_SAT_COUNT_SHIFT) + + +// Register CACC_D_CYA_0 +#define CACC_D_CYA_0 _MK_ADDR_CONST(0x7034) +#define CACC_D_CYA_0_CYA_SHIFT _MK_SHIFT_CONST(0) +#define CACC_D_CYA_0_CYA_FIELD _MK_FIELD_CONST(0xffffffff, CACC_D_CYA_0_CYA_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register SDP_RDMA_S_STATUS_0 +#define SDP_RDMA_S_STATUS_0 _MK_ADDR_CONST(0x8000) +#define SDP_RDMA_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_S_STATUS_0_STATUS_0_SHIFT) +#define SDP_RDMA_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define SDP_RDMA_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define SDP_RDMA_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define SDP_RDMA_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define SDP_RDMA_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_S_STATUS_0_STATUS_1_SHIFT) +#define SDP_RDMA_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define SDP_RDMA_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define SDP_RDMA_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register SDP_RDMA_S_POINTER_0 +#define SDP_RDMA_S_POINTER_0 _MK_ADDR_CONST(0x8004) +#define SDP_RDMA_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_S_POINTER_0_PRODUCER_SHIFT) +#define SDP_RDMA_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define SDP_RDMA_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define SDP_RDMA_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define SDP_RDMA_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_S_POINTER_0_CONSUMER_SHIFT) +#define SDP_RDMA_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define SDP_RDMA_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register SDP_RDMA_D_OP_ENABLE_0 +#define SDP_RDMA_D_OP_ENABLE_0 _MK_ADDR_CONST(0x8008) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register SDP_RDMA_D_DATA_CUBE_WIDTH_0 +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0 _MK_ADDR_CONST(0x800c) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, SDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT) + + +// Register SDP_RDMA_D_DATA_CUBE_HEIGHT_0 +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0 _MK_ADDR_CONST(0x8010) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, SDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT) + + +// Register SDP_RDMA_D_DATA_CUBE_CHANNEL_0 +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0 _MK_ADDR_CONST(0x8014) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, SDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT) + + +// Register SDP_RDMA_D_SRC_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0x8018) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT) + + +// Register SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0x801c) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT) + + +// Register SDP_RDMA_D_SRC_LINE_STRIDE_0 +#define SDP_RDMA_D_SRC_LINE_STRIDE_0 _MK_ADDR_CONST(0x8020) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_SRC_SURFACE_STRIDE_0 +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0 _MK_ADDR_CONST(0x8024) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_BRDMA_CFG_0 +#define SDP_RDMA_D_BRDMA_CFG_0 _MK_ADDR_CONST(0x8028) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_SHIFT) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_NO _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DISABLE_YES _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_SHIFT _MK_SHIFT_CONST(1) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_SHIFT) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_MUL _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_ALU _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_USE_BOTH _MK_ENUM_CONST(0x2) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_SHIFT _MK_SHIFT_CONST(3) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_SHIFT) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_ONE_BYTE _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_SIZE_TWO_BYTE _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_SHIFT _MK_SHIFT_CONST(4) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_SHIFT) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_PER_KERNEL _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_DATA_MODE_PER_ELEMENT _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_SHIFT _MK_SHIFT_CONST(5) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_SHIFT) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_BRDMA_CFG_0_BRDMA_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register SDP_RDMA_D_BS_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0x802c) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BS_BASE_ADDR_LOW_0_BS_BASE_ADDR_LOW_SHIFT) + + +// Register SDP_RDMA_D_BS_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0x8030) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BS_BASE_ADDR_HIGH_0_BS_BASE_ADDR_HIGH_SHIFT) + + +// Register SDP_RDMA_D_BS_LINE_STRIDE_0 +#define SDP_RDMA_D_BS_LINE_STRIDE_0 _MK_ADDR_CONST(0x8034) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BS_LINE_STRIDE_0_BS_LINE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_BS_SURFACE_STRIDE_0 +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0 _MK_ADDR_CONST(0x8038) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BS_SURFACE_STRIDE_0_BS_SURFACE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_BS_BATCH_STRIDE_0 +#define SDP_RDMA_D_BS_BATCH_STRIDE_0 _MK_ADDR_CONST(0x803c) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BS_BATCH_STRIDE_0_BS_BATCH_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_NRDMA_CFG_0 +#define SDP_RDMA_D_NRDMA_CFG_0 _MK_ADDR_CONST(0x8040) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_SHIFT) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_NO _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DISABLE_YES _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_SHIFT _MK_SHIFT_CONST(1) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_SHIFT) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_MUL _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_ALU _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_USE_BOTH _MK_ENUM_CONST(0x2) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_SHIFT _MK_SHIFT_CONST(3) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_SHIFT) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_ONE_BYTE _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_SIZE_TWO_BYTE _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_SHIFT _MK_SHIFT_CONST(4) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_SHIFT) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_PER_KERNEL _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_DATA_MODE_PER_ELEMENT _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_SHIFT _MK_SHIFT_CONST(5) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_SHIFT) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_NRDMA_CFG_0_NRDMA_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register SDP_RDMA_D_BN_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0x8044) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BN_BASE_ADDR_LOW_0_BN_BASE_ADDR_LOW_SHIFT) + + +// Register SDP_RDMA_D_BN_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0x8048) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BN_BASE_ADDR_HIGH_0_BN_BASE_ADDR_HIGH_SHIFT) + + +// Register SDP_RDMA_D_BN_LINE_STRIDE_0 +#define SDP_RDMA_D_BN_LINE_STRIDE_0 _MK_ADDR_CONST(0x804c) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BN_LINE_STRIDE_0_BN_LINE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_BN_SURFACE_STRIDE_0 +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0 _MK_ADDR_CONST(0x8050) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BN_SURFACE_STRIDE_0_BN_SURFACE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_BN_BATCH_STRIDE_0 +#define SDP_RDMA_D_BN_BATCH_STRIDE_0 _MK_ADDR_CONST(0x8054) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_BN_BATCH_STRIDE_0_BN_BATCH_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_ERDMA_CFG_0 +#define SDP_RDMA_D_ERDMA_CFG_0 _MK_ADDR_CONST(0x8058) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_SHIFT) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_NO _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DISABLE_YES _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_SHIFT _MK_SHIFT_CONST(1) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_SHIFT) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_MUL _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_ALU _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_USE_BOTH _MK_ENUM_CONST(0x2) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_SHIFT _MK_SHIFT_CONST(3) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_SHIFT) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_ONE_BYTE _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_SIZE_TWO_BYTE _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_SHIFT _MK_SHIFT_CONST(4) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_SHIFT) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_PER_KERNEL _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_DATA_MODE_PER_ELEMENT _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_SHIFT _MK_SHIFT_CONST(5) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_SHIFT) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_ERDMA_CFG_0_ERDMA_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register SDP_RDMA_D_EW_BASE_ADDR_LOW_0 +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0x805c) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_EW_BASE_ADDR_LOW_0_EW_BASE_ADDR_LOW_SHIFT) + + +// Register SDP_RDMA_D_EW_BASE_ADDR_HIGH_0 +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0x8060) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_EW_BASE_ADDR_HIGH_0_EW_BASE_ADDR_HIGH_SHIFT) + + +// Register SDP_RDMA_D_EW_LINE_STRIDE_0 +#define SDP_RDMA_D_EW_LINE_STRIDE_0 _MK_ADDR_CONST(0x8064) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_EW_LINE_STRIDE_0_EW_LINE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_EW_SURFACE_STRIDE_0 +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0 _MK_ADDR_CONST(0x8068) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_EW_SURFACE_STRIDE_0_EW_SURFACE_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_EW_BATCH_STRIDE_0 +#define SDP_RDMA_D_EW_BATCH_STRIDE_0 _MK_ADDR_CONST(0x806c) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_EW_BATCH_STRIDE_0_EW_BATCH_STRIDE_SHIFT) + + +// Register SDP_RDMA_D_FEATURE_MODE_CFG_0 +#define SDP_RDMA_D_FEATURE_MODE_CFG_0 _MK_ADDR_CONST(0x8070) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_OFF _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_FLYING_MODE_ON _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT _MK_SHIFT_CONST(1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_OFF _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_WINOGRAD_ON _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_SHIFT _MK_SHIFT_CONST(2) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_SHIFT) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_IN_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_SHIFT _MK_SHIFT_CONST(4) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_SHIFT) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_PROC_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_SHIFT _MK_SHIFT_CONST(6) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_FIELD _MK_FIELD_CONST(0x3, SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_SHIFT) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_OUT_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT _MK_SHIFT_CONST(8) +#define SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_FIELD _MK_FIELD_CONST(0x1f, SDP_RDMA_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT) + + +// Register SDP_RDMA_D_SRC_DMA_CFG_0 +#define SDP_RDMA_D_SRC_DMA_CFG_0 _MK_ADDR_CONST(0x8074) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0 +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0 _MK_ADDR_CONST(0x8078) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT) + + +// Register SDP_RDMA_D_STATUS_INF_INPUT_NUM_0 +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0 _MK_ADDR_CONST(0x807c) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT) + + +// Register SDP_RDMA_D_PERF_ENABLE_0 +#define SDP_RDMA_D_PERF_ENABLE_0 _MK_ADDR_CONST(0x8080) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_NO _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_DMA_EN_YES _MK_ENUM_CONST(0x1) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT _MK_SHIFT_CONST(1) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_FIELD _MK_FIELD_CONST(0x1, SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_NO _MK_ENUM_CONST(0x0) +#define SDP_RDMA_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_YES _MK_ENUM_CONST(0x1) + + +// Register SDP_RDMA_D_PERF_MRDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0 _MK_ADDR_CONST(0x8084) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_PERF_MRDMA_READ_STALL_0_MRDMA_STALL_SHIFT) + + +// Register SDP_RDMA_D_PERF_BRDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0 _MK_ADDR_CONST(0x8088) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_PERF_BRDMA_READ_STALL_0_BRDMA_STALL_SHIFT) + + +// Register SDP_RDMA_D_PERF_NRDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0 _MK_ADDR_CONST(0x808c) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_PERF_NRDMA_READ_STALL_0_NRDMA_STALL_SHIFT) + + +// Register SDP_RDMA_D_PERF_ERDMA_READ_STALL_0 +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0 _MK_ADDR_CONST(0x8090) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_FIELD _MK_FIELD_CONST(0xffffffff, SDP_RDMA_D_PERF_ERDMA_READ_STALL_0_ERDMA_STALL_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register SDP_S_STATUS_0 +#define SDP_S_STATUS_0 _MK_ADDR_CONST(0x9000) +#define SDP_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, SDP_S_STATUS_0_STATUS_0_SHIFT) +#define SDP_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define SDP_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define SDP_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define SDP_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define SDP_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, SDP_S_STATUS_0_STATUS_1_SHIFT) +#define SDP_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define SDP_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define SDP_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register SDP_S_POINTER_0 +#define SDP_S_POINTER_0 _MK_ADDR_CONST(0x9004) +#define SDP_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, SDP_S_POINTER_0_PRODUCER_SHIFT) +#define SDP_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define SDP_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define SDP_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define SDP_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, SDP_S_POINTER_0_CONSUMER_SHIFT) +#define SDP_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define SDP_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register SDP_S_LUT_ACCESS_CFG_0 +#define SDP_S_LUT_ACCESS_CFG_0 _MK_ADDR_CONST(0x9008) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_FIELD _MK_FIELD_CONST(0x3ff, SDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT _MK_SHIFT_CONST(16) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_FIELD _MK_FIELD_CONST(0x1, SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LE _MK_ENUM_CONST(0x0) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LO _MK_ENUM_CONST(0x1) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT _MK_SHIFT_CONST(17) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_FIELD _MK_FIELD_CONST(0x1, SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_READ _MK_ENUM_CONST(0x0) +#define SDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_WRITE _MK_ENUM_CONST(0x1) + + +// Register SDP_S_LUT_ACCESS_DATA_0 +#define SDP_S_LUT_ACCESS_DATA_0 _MK_ADDR_CONST(0x900c) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_FIELD _MK_FIELD_CONST(0xffff, SDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT) + + +// Register SDP_S_LUT_CFG_0 +#define SDP_S_LUT_CFG_0 _MK_ADDR_CONST(0x9010) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_FIELD _MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_EXPONENT _MK_ENUM_CONST(0x0) +#define SDP_S_LUT_CFG_0_LUT_LE_FUNCTION_LINEAR _MK_ENUM_CONST(0x1) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT _MK_SHIFT_CONST(4) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_FIELD _MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LE _MK_ENUM_CONST(0x0) +#define SDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LO _MK_ENUM_CONST(0x1) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT _MK_SHIFT_CONST(5) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_FIELD _MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LE _MK_ENUM_CONST(0x0) +#define SDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LO _MK_ENUM_CONST(0x1) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT _MK_SHIFT_CONST(6) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_FIELD _MK_FIELD_CONST(0x1, SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LE _MK_ENUM_CONST(0x0) +#define SDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LO _MK_ENUM_CONST(0x1) + + +// Register SDP_S_LUT_INFO_0 +#define SDP_S_LUT_INFO_0 _MK_ADDR_CONST(0x9014) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_FIELD _MK_FIELD_CONST(0xff, SDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT _MK_SHIFT_CONST(8) +#define SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_FIELD _MK_FIELD_CONST(0xff, SDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT _MK_SHIFT_CONST(16) +#define SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_FIELD _MK_FIELD_CONST(0xff, SDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT) + + +// Register SDP_S_LUT_LE_START_0 +#define SDP_S_LUT_LE_START_0 _MK_ADDR_CONST(0x9018) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LE_START_0_LUT_LE_START_FIELD _MK_FIELD_CONST(0xffffffff, SDP_S_LUT_LE_START_0_LUT_LE_START_SHIFT) + + +// Register SDP_S_LUT_LE_END_0 +#define SDP_S_LUT_LE_END_0 _MK_ADDR_CONST(0x901c) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LE_END_0_LUT_LE_END_FIELD _MK_FIELD_CONST(0xffffffff, SDP_S_LUT_LE_END_0_LUT_LE_END_SHIFT) + + +// Register SDP_S_LUT_LO_START_0 +#define SDP_S_LUT_LO_START_0 _MK_ADDR_CONST(0x9020) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LO_START_0_LUT_LO_START_FIELD _MK_FIELD_CONST(0xffffffff, SDP_S_LUT_LO_START_0_LUT_LO_START_SHIFT) + + +// Register SDP_S_LUT_LO_END_0 +#define SDP_S_LUT_LO_END_0 _MK_ADDR_CONST(0x9024) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LO_END_0_LUT_LO_END_FIELD _MK_FIELD_CONST(0xffffffff, SDP_S_LUT_LO_END_0_LUT_LO_END_SHIFT) + + +// Register SDP_S_LUT_LE_SLOPE_SCALE_0 +#define SDP_S_LUT_LE_SLOPE_SCALE_0 _MK_ADDR_CONST(0x9028) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT _MK_SHIFT_CONST(16) +#define SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, SDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT) + + +// Register SDP_S_LUT_LE_SLOPE_SHIFT_0 +#define SDP_S_LUT_LE_SLOPE_SHIFT_0 _MK_ADDR_CONST(0x902c) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(5) +#define SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, SDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT) + + +// Register SDP_S_LUT_LO_SLOPE_SCALE_0 +#define SDP_S_LUT_LO_SLOPE_SCALE_0 _MK_ADDR_CONST(0x9030) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT _MK_SHIFT_CONST(16) +#define SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, SDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT) + + +// Register SDP_S_LUT_LO_SLOPE_SHIFT_0 +#define SDP_S_LUT_LO_SLOPE_SHIFT_0 _MK_ADDR_CONST(0x9034) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(0) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(5) +#define SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, SDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT) + + +// Register SDP_D_OP_ENABLE_0 +#define SDP_D_OP_ENABLE_0 _MK_ADDR_CONST(0x9038) +#define SDP_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, SDP_D_OP_ENABLE_0_OP_EN_SHIFT) +#define SDP_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define SDP_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register SDP_D_DATA_CUBE_WIDTH_0 +#define SDP_D_DATA_CUBE_WIDTH_0 _MK_ADDR_CONST(0x903c) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DATA_CUBE_WIDTH_0_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, SDP_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT) + + +// Register SDP_D_DATA_CUBE_HEIGHT_0 +#define SDP_D_DATA_CUBE_HEIGHT_0 _MK_ADDR_CONST(0x9040) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, SDP_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT) + + +// Register SDP_D_DATA_CUBE_CHANNEL_0 +#define SDP_D_DATA_CUBE_CHANNEL_0 _MK_ADDR_CONST(0x9044) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, SDP_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT) + + +// Register SDP_D_DST_BASE_ADDR_LOW_0 +#define SDP_D_DST_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0x9048) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT) + + +// Register SDP_D_DST_BASE_ADDR_HIGH_0 +#define SDP_D_DST_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0x904c) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT) + + +// Register SDP_D_DST_LINE_STRIDE_0 +#define SDP_D_DST_LINE_STRIDE_0 _MK_ADDR_CONST(0x9050) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT) + + +// Register SDP_D_DST_SURFACE_STRIDE_0 +#define SDP_D_DST_SURFACE_STRIDE_0 _MK_ADDR_CONST(0x9054) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT) + + +// Register SDP_D_DP_BS_CFG_0 +#define SDP_D_DP_BS_CFG_0 _MK_ADDR_CONST(0x9058) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_BYPASS_SHIFT) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_CFG_0_BS_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_SHIFT _MK_SHIFT_CONST(1) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_SHIFT) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_CFG_0_BS_ALU_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SHIFT _MK_SHIFT_CONST(2) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_FIELD _MK_FIELD_CONST(0x3, SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SHIFT) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_MAX _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_MIN _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BS_CFG_0_BS_ALU_ALGO_SUM _MK_ENUM_CONST(0x2) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_SHIFT _MK_SHIFT_CONST(4) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_SHIFT) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_CFG_0_BS_MUL_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_SHIFT _MK_SHIFT_CONST(5) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_SHIFT) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_CFG_0_BS_MUL_PRELU_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_SHIFT _MK_SHIFT_CONST(6) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_SHIFT) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_CFG_0_BS_RELU_BYPASS_YES _MK_ENUM_CONST(0x1) + + +// Register SDP_D_DP_BS_ALU_CFG_0 +#define SDP_D_DP_BS_ALU_CFG_0 _MK_ADDR_CONST(0x905c) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_SHIFT) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_REG _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SRC_MEM _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_SHIFT _MK_SHIFT_CONST(8) +#define SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_FIELD _MK_FIELD_CONST(0x3f, SDP_D_DP_BS_ALU_CFG_0_BS_ALU_SHIFT_VALUE_SHIFT) + + +// Register SDP_D_DP_BS_ALU_SRC_VALUE_0 +#define SDP_D_DP_BS_ALU_SRC_VALUE_0 _MK_ADDR_CONST(0x9060) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_FIELD _MK_FIELD_CONST(0xffff, SDP_D_DP_BS_ALU_SRC_VALUE_0_BS_ALU_OPERAND_SHIFT) + + +// Register SDP_D_DP_BS_MUL_CFG_0 +#define SDP_D_DP_BS_MUL_CFG_0 _MK_ADDR_CONST(0x9064) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_SHIFT) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_REG _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SRC_MEM _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_SHIFT _MK_SHIFT_CONST(8) +#define SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_FIELD _MK_FIELD_CONST(0xff, SDP_D_DP_BS_MUL_CFG_0_BS_MUL_SHIFT_VALUE_SHIFT) + + +// Register SDP_D_DP_BS_MUL_SRC_VALUE_0 +#define SDP_D_DP_BS_MUL_SRC_VALUE_0 _MK_ADDR_CONST(0x9068) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_FIELD _MK_FIELD_CONST(0xffff, SDP_D_DP_BS_MUL_SRC_VALUE_0_BS_MUL_OPERAND_SHIFT) + + +// Register SDP_D_DP_BN_CFG_0 +#define SDP_D_DP_BN_CFG_0 _MK_ADDR_CONST(0x906c) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_BYPASS_SHIFT) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_CFG_0_BN_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_SHIFT _MK_SHIFT_CONST(1) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_SHIFT) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_CFG_0_BN_ALU_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SHIFT _MK_SHIFT_CONST(2) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_FIELD _MK_FIELD_CONST(0x3, SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SHIFT) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_MAX _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_MIN _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BN_CFG_0_BN_ALU_ALGO_SUM _MK_ENUM_CONST(0x2) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_SHIFT _MK_SHIFT_CONST(4) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_SHIFT) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_CFG_0_BN_MUL_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_SHIFT _MK_SHIFT_CONST(5) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_SHIFT) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_CFG_0_BN_MUL_PRELU_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_SHIFT _MK_SHIFT_CONST(6) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_SHIFT) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_CFG_0_BN_RELU_BYPASS_YES _MK_ENUM_CONST(0x1) + + +// Register SDP_D_DP_BN_ALU_CFG_0 +#define SDP_D_DP_BN_ALU_CFG_0 _MK_ADDR_CONST(0x9070) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_SHIFT) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_REG _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SRC_MEM _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_SHIFT _MK_SHIFT_CONST(8) +#define SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_FIELD _MK_FIELD_CONST(0x3f, SDP_D_DP_BN_ALU_CFG_0_BN_ALU_SHIFT_VALUE_SHIFT) + + +// Register SDP_D_DP_BN_ALU_SRC_VALUE_0 +#define SDP_D_DP_BN_ALU_SRC_VALUE_0 _MK_ADDR_CONST(0x9074) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_FIELD _MK_FIELD_CONST(0xffff, SDP_D_DP_BN_ALU_SRC_VALUE_0_BN_ALU_OPERAND_SHIFT) + + +// Register SDP_D_DP_BN_MUL_CFG_0 +#define SDP_D_DP_BN_MUL_CFG_0 _MK_ADDR_CONST(0x9078) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_SHIFT) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_REG _MK_ENUM_CONST(0x0) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SRC_MEM _MK_ENUM_CONST(0x1) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_SHIFT _MK_SHIFT_CONST(8) +#define SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_FIELD _MK_FIELD_CONST(0xff, SDP_D_DP_BN_MUL_CFG_0_BN_MUL_SHIFT_VALUE_SHIFT) + + +// Register SDP_D_DP_BN_MUL_SRC_VALUE_0 +#define SDP_D_DP_BN_MUL_SRC_VALUE_0 _MK_ADDR_CONST(0x907c) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_FIELD _MK_FIELD_CONST(0xffff, SDP_D_DP_BN_MUL_SRC_VALUE_0_BN_MUL_OPERAND_SHIFT) + + +// Register SDP_D_DP_EW_CFG_0 +#define SDP_D_DP_EW_CFG_0 _MK_ADDR_CONST(0x9080) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_BYPASS_SHIFT) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_CFG_0_EW_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_SHIFT _MK_SHIFT_CONST(1) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_SHIFT) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_CFG_0_EW_ALU_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SHIFT _MK_SHIFT_CONST(2) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_FIELD _MK_FIELD_CONST(0x3, SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SHIFT) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_MAX _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_MIN _MK_ENUM_CONST(0x1) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_SUM _MK_ENUM_CONST(0x2) +#define SDP_D_DP_EW_CFG_0_EW_ALU_ALGO_EQL _MK_ENUM_CONST(0x3) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_SHIFT _MK_SHIFT_CONST(4) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_SHIFT) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_CFG_0_EW_MUL_BYPASS_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_SHIFT _MK_SHIFT_CONST(5) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_SHIFT) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_CFG_0_EW_MUL_PRELU_YES _MK_ENUM_CONST(0x1) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_SHIFT _MK_SHIFT_CONST(6) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_SHIFT) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_CFG_0_EW_LUT_BYPASS_YES _MK_ENUM_CONST(0x1) + + +// Register SDP_D_DP_EW_ALU_CFG_0 +#define SDP_D_DP_EW_ALU_CFG_0 _MK_ADDR_CONST(0x9084) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_SHIFT) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_REG _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_SRC_MEM _MK_ENUM_CONST(0x1) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_SHIFT _MK_SHIFT_CONST(1) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_SHIFT) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_ALU_CFG_0_EW_ALU_CVT_BYPASS_YES _MK_ENUM_CONST(0x1) + + +// Register SDP_D_DP_EW_ALU_SRC_VALUE_0 +#define SDP_D_DP_EW_ALU_SRC_VALUE_0 _MK_ADDR_CONST(0x9088) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DP_EW_ALU_SRC_VALUE_0_EW_ALU_OPERAND_SHIFT) + + +// Register SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0 +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0 _MK_ADDR_CONST(0x908c) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DP_EW_ALU_CVT_OFFSET_VALUE_0_EW_ALU_CVT_OFFSET_SHIFT) + + +// Register SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0 +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0 _MK_ADDR_CONST(0x9090) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_FIELD _MK_FIELD_CONST(0xffff, SDP_D_DP_EW_ALU_CVT_SCALE_VALUE_0_EW_ALU_CVT_SCALE_SHIFT) + + +// Register SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0 +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0 _MK_ADDR_CONST(0x9094) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_FIELD _MK_FIELD_CONST(0x3f, SDP_D_DP_EW_ALU_CVT_TRUNCATE_VALUE_0_EW_ALU_CVT_TRUNCATE_SHIFT) + + +// Register SDP_D_DP_EW_MUL_CFG_0 +#define SDP_D_DP_EW_MUL_CFG_0 _MK_ADDR_CONST(0x9098) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_SHIFT) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_REG _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_SRC_MEM _MK_ENUM_CONST(0x1) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_SHIFT _MK_SHIFT_CONST(1) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_FIELD _MK_FIELD_CONST(0x1, SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_SHIFT) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_NO _MK_ENUM_CONST(0x0) +#define SDP_D_DP_EW_MUL_CFG_0_EW_MUL_CVT_BYPASS_YES _MK_ENUM_CONST(0x1) + + +// Register SDP_D_DP_EW_MUL_SRC_VALUE_0 +#define SDP_D_DP_EW_MUL_SRC_VALUE_0 _MK_ADDR_CONST(0x909c) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DP_EW_MUL_SRC_VALUE_0_EW_MUL_OPERAND_SHIFT) + + +// Register SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0 +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0 _MK_ADDR_CONST(0x90a0) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DP_EW_MUL_CVT_OFFSET_VALUE_0_EW_MUL_CVT_OFFSET_SHIFT) + + +// Register SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0 +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0 _MK_ADDR_CONST(0x90a4) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_FIELD _MK_FIELD_CONST(0xffff, SDP_D_DP_EW_MUL_CVT_SCALE_VALUE_0_EW_MUL_CVT_SCALE_SHIFT) + + +// Register SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0 +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0 _MK_ADDR_CONST(0x90a8) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_FIELD _MK_FIELD_CONST(0x3f, SDP_D_DP_EW_MUL_CVT_TRUNCATE_VALUE_0_EW_MUL_CVT_TRUNCATE_SHIFT) + + +// Register SDP_D_DP_EW_TRUNCATE_VALUE_0 +#define SDP_D_DP_EW_TRUNCATE_VALUE_0 _MK_ADDR_CONST(0x90ac) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_FIELD _MK_FIELD_CONST(0x3ff, SDP_D_DP_EW_TRUNCATE_VALUE_0_EW_TRUNCATE_SHIFT) + + +// Register SDP_D_FEATURE_MODE_CFG_0 +#define SDP_D_FEATURE_MODE_CFG_0 _MK_ADDR_CONST(0x90b0) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_FIELD _MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_SHIFT) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_OFF _MK_ENUM_CONST(0x0) +#define SDP_D_FEATURE_MODE_CFG_0_FLYING_MODE_ON _MK_ENUM_CONST(0x1) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_SHIFT _MK_SHIFT_CONST(1) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_FIELD _MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_SHIFT) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_MEM _MK_ENUM_CONST(0x0) +#define SDP_D_FEATURE_MODE_CFG_0_OUTPUT_DST_PDP _MK_ENUM_CONST(0x1) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT _MK_SHIFT_CONST(2) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_FIELD _MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_SHIFT) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_OFF _MK_ENUM_CONST(0x0) +#define SDP_D_FEATURE_MODE_CFG_0_WINOGRAD_ON _MK_ENUM_CONST(0x1) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_SHIFT _MK_SHIFT_CONST(3) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_FIELD _MK_FIELD_CONST(0x1, SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_SHIFT) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_DISABLE _MK_ENUM_CONST(0x0) +#define SDP_D_FEATURE_MODE_CFG_0_NAN_TO_ZERO_ENABLE _MK_ENUM_CONST(0x1) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT _MK_SHIFT_CONST(8) +#define SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_FIELD _MK_FIELD_CONST(0x1f, SDP_D_FEATURE_MODE_CFG_0_BATCH_NUMBER_SHIFT) + + +// Register SDP_D_DST_DMA_CFG_0 +#define SDP_D_DST_DMA_CFG_0 _MK_ADDR_CONST(0x90b4) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define SDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register SDP_D_DST_BATCH_STRIDE_0 +#define SDP_D_DST_BATCH_STRIDE_0 _MK_ADDR_CONST(0x90b8) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_DST_BATCH_STRIDE_0_DST_BATCH_STRIDE_SHIFT) + + +// Register SDP_D_DATA_FORMAT_0 +#define SDP_D_DATA_FORMAT_0 _MK_ADDR_CONST(0x90bc) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_FIELD _MK_FIELD_CONST(0x3, SDP_D_DATA_FORMAT_0_PROC_PRECISION_SHIFT) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define SDP_D_DATA_FORMAT_0_PROC_PRECISION_FP16 _MK_ENUM_CONST(0x2) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_SHIFT _MK_SHIFT_CONST(2) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_FIELD _MK_FIELD_CONST(0x3, SDP_D_DATA_FORMAT_0_OUT_PRECISION_SHIFT) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define SDP_D_DATA_FORMAT_0_OUT_PRECISION_FP16 _MK_ENUM_CONST(0x2) + + +// Register SDP_D_CVT_OFFSET_0 +#define SDP_D_CVT_OFFSET_0 _MK_ADDR_CONST(0x90c0) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_CVT_OFFSET_0_CVT_OFFSET_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_CVT_OFFSET_0_CVT_OFFSET_SHIFT) + + +// Register SDP_D_CVT_SCALE_0 +#define SDP_D_CVT_SCALE_0 _MK_ADDR_CONST(0x90c4) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_CVT_SCALE_0_CVT_SCALE_FIELD _MK_FIELD_CONST(0xffff, SDP_D_CVT_SCALE_0_CVT_SCALE_SHIFT) + + +// Register SDP_D_CVT_SHIFT_0 +#define SDP_D_CVT_SHIFT_0 _MK_ADDR_CONST(0x90c8) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_CVT_SHIFT_0_CVT_SHIFT_FIELD _MK_FIELD_CONST(0x3f, SDP_D_CVT_SHIFT_0_CVT_SHIFT_SHIFT) + + +// Register SDP_D_STATUS_0 +#define SDP_D_STATUS_0 _MK_ADDR_CONST(0x90cc) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_STATUS_0_STATUS_UNEQUAL_FIELD _MK_FIELD_CONST(0x1, SDP_D_STATUS_0_STATUS_UNEQUAL_SHIFT) + + +// Register SDP_D_STATUS_NAN_INPUT_NUM_0 +#define SDP_D_STATUS_NAN_INPUT_NUM_0 _MK_ADDR_CONST(0x90d0) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_STATUS_NAN_INPUT_NUM_0_STATUS_NAN_INPUT_NUM_SHIFT) + + +// Register SDP_D_STATUS_INF_INPUT_NUM_0 +#define SDP_D_STATUS_INF_INPUT_NUM_0 _MK_ADDR_CONST(0x90d4) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_STATUS_INF_INPUT_NUM_0_STATUS_INF_INPUT_NUM_SHIFT) + + +// Register SDP_D_STATUS_NAN_OUTPUT_NUM_0 +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0 _MK_ADDR_CONST(0x90d8) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_STATUS_NAN_OUTPUT_NUM_0_STATUS_NAN_OUTPUT_NUM_SHIFT) + + +// Register SDP_D_PERF_ENABLE_0 +#define SDP_D_PERF_ENABLE_0 _MK_ADDR_CONST(0x90dc) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_FIELD _MK_FIELD_CONST(0x1, SDP_D_PERF_ENABLE_0_PERF_DMA_EN_SHIFT) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_NO _MK_ENUM_CONST(0x0) +#define SDP_D_PERF_ENABLE_0_PERF_DMA_EN_YES _MK_ENUM_CONST(0x1) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_SHIFT _MK_SHIFT_CONST(1) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_FIELD _MK_FIELD_CONST(0x1, SDP_D_PERF_ENABLE_0_PERF_LUT_EN_SHIFT) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_NO _MK_ENUM_CONST(0x0) +#define SDP_D_PERF_ENABLE_0_PERF_LUT_EN_YES _MK_ENUM_CONST(0x1) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_SHIFT _MK_SHIFT_CONST(2) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_FIELD _MK_FIELD_CONST(0x1, SDP_D_PERF_ENABLE_0_PERF_SAT_EN_SHIFT) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_NO _MK_ENUM_CONST(0x0) +#define SDP_D_PERF_ENABLE_0_PERF_SAT_EN_YES _MK_ENUM_CONST(0x1) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT _MK_SHIFT_CONST(3) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_FIELD _MK_FIELD_CONST(0x1, SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_SHIFT) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_NO _MK_ENUM_CONST(0x0) +#define SDP_D_PERF_ENABLE_0_PERF_NAN_INF_COUNT_EN_YES _MK_ENUM_CONST(0x1) + + +// Register SDP_D_PERF_WDMA_WRITE_STALL_0 +#define SDP_D_PERF_WDMA_WRITE_STALL_0 _MK_ADDR_CONST(0x90e0) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_PERF_WDMA_WRITE_STALL_0_WDMA_STALL_SHIFT) + + +// Register SDP_D_PERF_LUT_UFLOW_0 +#define SDP_D_PERF_LUT_UFLOW_0 _MK_ADDR_CONST(0x90e4) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_PERF_LUT_UFLOW_0_LUT_UFLOW_SHIFT) + + +// Register SDP_D_PERF_LUT_OFLOW_0 +#define SDP_D_PERF_LUT_OFLOW_0 _MK_ADDR_CONST(0x90e8) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_PERF_LUT_OFLOW_0_LUT_OFLOW_SHIFT) + + +// Register SDP_D_PERF_OUT_SATURATION_0 +#define SDP_D_PERF_OUT_SATURATION_0 _MK_ADDR_CONST(0x90ec) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_PERF_OUT_SATURATION_0_OUT_SATURATION_SHIFT) + + +// Register SDP_D_PERF_LUT_HYBRID_0 +#define SDP_D_PERF_LUT_HYBRID_0 _MK_ADDR_CONST(0x90f0) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_PERF_LUT_HYBRID_0_LUT_HYBRID_SHIFT) + + +// Register SDP_D_PERF_LUT_LE_HIT_0 +#define SDP_D_PERF_LUT_LE_HIT_0 _MK_ADDR_CONST(0x90f4) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_PERF_LUT_LE_HIT_0_LUT_LE_HIT_SHIFT) + + +// Register SDP_D_PERF_LUT_LO_HIT_0 +#define SDP_D_PERF_LUT_LO_HIT_0 _MK_ADDR_CONST(0x90f8) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_SHIFT _MK_SHIFT_CONST(0) +#define SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_FIELD _MK_FIELD_CONST(0xffffffff, SDP_D_PERF_LUT_LO_HIT_0_LUT_LO_HIT_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register PDP_RDMA_S_STATUS_0 +#define PDP_RDMA_S_STATUS_0 _MK_ADDR_CONST(0xa000) +#define PDP_RDMA_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, PDP_RDMA_S_STATUS_0_STATUS_0_SHIFT) +#define PDP_RDMA_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define PDP_RDMA_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define PDP_RDMA_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define PDP_RDMA_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define PDP_RDMA_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, PDP_RDMA_S_STATUS_0_STATUS_1_SHIFT) +#define PDP_RDMA_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define PDP_RDMA_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define PDP_RDMA_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register PDP_RDMA_S_POINTER_0 +#define PDP_RDMA_S_POINTER_0 _MK_ADDR_CONST(0xa004) +#define PDP_RDMA_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, PDP_RDMA_S_POINTER_0_PRODUCER_SHIFT) +#define PDP_RDMA_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define PDP_RDMA_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define PDP_RDMA_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define PDP_RDMA_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, PDP_RDMA_S_POINTER_0_CONSUMER_SHIFT) +#define PDP_RDMA_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define PDP_RDMA_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register PDP_RDMA_D_OP_ENABLE_0 +#define PDP_RDMA_D_OP_ENABLE_0 _MK_ADDR_CONST(0xa008) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, PDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define PDP_RDMA_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0 +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0 _MK_ADDR_CONST(0xa00c) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, PDP_RDMA_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT) + + +// Register PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0 +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0 _MK_ADDR_CONST(0xa010) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, PDP_RDMA_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT) + + +// Register PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0 +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0 _MK_ADDR_CONST(0xa014) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, PDP_RDMA_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT) + + +// Register PDP_RDMA_D_FLYING_MODE_0 +#define PDP_RDMA_D_FLYING_MODE_0 _MK_ADDR_CONST(0xa018) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_FIELD _MK_FIELD_CONST(0x1, PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_SHIFT) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_ON_FLYING _MK_ENUM_CONST(0x0) +#define PDP_RDMA_D_FLYING_MODE_0_FLYING_MODE_OFF_FLYING _MK_ENUM_CONST(0x1) + + +// Register PDP_RDMA_D_SRC_BASE_ADDR_LOW_0 +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0xa01c) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, PDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT) + + +// Register PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0xa020) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, PDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT) + + +// Register PDP_RDMA_D_SRC_LINE_STRIDE_0 +#define PDP_RDMA_D_SRC_LINE_STRIDE_0 _MK_ADDR_CONST(0xa024) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, PDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT) + + +// Register PDP_RDMA_D_SRC_SURFACE_STRIDE_0 +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0 _MK_ADDR_CONST(0xa028) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, PDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT) + + +// Register PDP_RDMA_D_SRC_RAM_CFG_0 +#define PDP_RDMA_D_SRC_RAM_CFG_0 _MK_ADDR_CONST(0xa02c) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_SHIFT) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define PDP_RDMA_D_SRC_RAM_CFG_0_SRC_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register PDP_RDMA_D_DATA_FORMAT_0 +#define PDP_RDMA_D_DATA_FORMAT_0 _MK_ADDR_CONST(0xa030) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FIELD _MK_FIELD_CONST(0x3, PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT8 _MK_ENUM_CONST(0x0) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT16 _MK_ENUM_CONST(0x1) +#define PDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FP16 _MK_ENUM_CONST(0x2) + + +// Register PDP_RDMA_D_OPERATION_MODE_CFG_0 +#define PDP_RDMA_D_OPERATION_MODE_CFG_0 _MK_ADDR_CONST(0xa034) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_FIELD _MK_FIELD_CONST(0xff, PDP_RDMA_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT) + + +// Register PDP_RDMA_D_POOLING_KERNEL_CFG_0 +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0 _MK_ADDR_CONST(0xa038) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_FIELD _MK_FIELD_CONST(0xf, PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_1 _MK_ENUM_CONST(0x0) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_2 _MK_ENUM_CONST(0x1) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_3 _MK_ENUM_CONST(0x2) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_4 _MK_ENUM_CONST(0x3) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_5 _MK_ENUM_CONST(0x4) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_6 _MK_ENUM_CONST(0x5) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_7 _MK_ENUM_CONST(0x6) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_8 _MK_ENUM_CONST(0x7) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT _MK_SHIFT_CONST(4) +#define PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_FIELD _MK_FIELD_CONST(0xf, PDP_RDMA_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT) + + +// Register PDP_RDMA_D_POOLING_PADDING_CFG_0 +#define PDP_RDMA_D_POOLING_PADDING_CFG_0 _MK_ADDR_CONST(0xa03c) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_FIELD _MK_FIELD_CONST(0xf, PDP_RDMA_D_POOLING_PADDING_CFG_0_PAD_WIDTH_SHIFT) + + +// Register PDP_RDMA_D_PARTIAL_WIDTH_IN_0 +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0 _MK_ADDR_CONST(0xa040) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_FIELD _MK_FIELD_CONST(0x3ff, PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT _MK_SHIFT_CONST(10) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_FIELD _MK_FIELD_CONST(0x3ff, PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT _MK_SHIFT_CONST(20) +#define PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_FIELD _MK_FIELD_CONST(0x3ff, PDP_RDMA_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT) + + +// Register PDP_RDMA_D_PERF_ENABLE_0 +#define PDP_RDMA_D_PERF_ENABLE_0 _MK_ADDR_CONST(0xa044) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_FIELD _MK_FIELD_CONST(0x1, PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DISABLE _MK_ENUM_CONST(0x0) +#define PDP_RDMA_D_PERF_ENABLE_0_DMA_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register PDP_RDMA_D_PERF_READ_STALL_0 +#define PDP_RDMA_D_PERF_READ_STALL_0 _MK_ADDR_CONST(0xa048) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_FIELD _MK_FIELD_CONST(0xffffffff, PDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT) + + +// Register PDP_RDMA_D_CYA_0 +#define PDP_RDMA_D_CYA_0 _MK_ADDR_CONST(0xa04c) +#define PDP_RDMA_D_CYA_0_CYA_SHIFT _MK_SHIFT_CONST(0) +#define PDP_RDMA_D_CYA_0_CYA_FIELD _MK_FIELD_CONST(0xffffffff, PDP_RDMA_D_CYA_0_CYA_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register PDP_S_STATUS_0 +#define PDP_S_STATUS_0 _MK_ADDR_CONST(0xb000) +#define PDP_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define PDP_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, PDP_S_STATUS_0_STATUS_0_SHIFT) +#define PDP_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define PDP_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define PDP_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define PDP_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define PDP_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, PDP_S_STATUS_0_STATUS_1_SHIFT) +#define PDP_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define PDP_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define PDP_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register PDP_S_POINTER_0 +#define PDP_S_POINTER_0 _MK_ADDR_CONST(0xb004) +#define PDP_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define PDP_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, PDP_S_POINTER_0_PRODUCER_SHIFT) +#define PDP_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define PDP_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define PDP_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define PDP_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, PDP_S_POINTER_0_CONSUMER_SHIFT) +#define PDP_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define PDP_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register PDP_D_OP_ENABLE_0 +#define PDP_D_OP_ENABLE_0 _MK_ADDR_CONST(0xb008) +#define PDP_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, PDP_D_OP_ENABLE_0_OP_EN_SHIFT) +#define PDP_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define PDP_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register PDP_D_DATA_CUBE_IN_WIDTH_0 +#define PDP_D_DATA_CUBE_IN_WIDTH_0 _MK_ADDR_CONST(0xb00c) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, PDP_D_DATA_CUBE_IN_WIDTH_0_CUBE_IN_WIDTH_SHIFT) + + +// Register PDP_D_DATA_CUBE_IN_HEIGHT_0 +#define PDP_D_DATA_CUBE_IN_HEIGHT_0 _MK_ADDR_CONST(0xb010) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, PDP_D_DATA_CUBE_IN_HEIGHT_0_CUBE_IN_HEIGHT_SHIFT) + + +// Register PDP_D_DATA_CUBE_IN_CHANNEL_0 +#define PDP_D_DATA_CUBE_IN_CHANNEL_0 _MK_ADDR_CONST(0xb014) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, PDP_D_DATA_CUBE_IN_CHANNEL_0_CUBE_IN_CHANNEL_SHIFT) + + +// Register PDP_D_DATA_CUBE_OUT_WIDTH_0 +#define PDP_D_DATA_CUBE_OUT_WIDTH_0 _MK_ADDR_CONST(0xb018) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, PDP_D_DATA_CUBE_OUT_WIDTH_0_CUBE_OUT_WIDTH_SHIFT) + + +// Register PDP_D_DATA_CUBE_OUT_HEIGHT_0 +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0 _MK_ADDR_CONST(0xb01c) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, PDP_D_DATA_CUBE_OUT_HEIGHT_0_CUBE_OUT_HEIGHT_SHIFT) + + +// Register PDP_D_DATA_CUBE_OUT_CHANNEL_0 +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0 _MK_ADDR_CONST(0xb020) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, PDP_D_DATA_CUBE_OUT_CHANNEL_0_CUBE_OUT_CHANNEL_SHIFT) + + +// Register PDP_D_OPERATION_MODE_CFG_0 +#define PDP_D_OPERATION_MODE_CFG_0 _MK_ADDR_CONST(0xb024) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_FIELD _MK_FIELD_CONST(0x3, PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_SHIFT) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_POOLING_METHOD_AVERAGE _MK_ENUM_CONST(0x0) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_POOLING_METHOD_MAX _MK_ENUM_CONST(0x1) +#define PDP_D_OPERATION_MODE_CFG_0_POOLING_METHOD_POOLING_METHOD_MIN _MK_ENUM_CONST(0x2) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_SHIFT _MK_SHIFT_CONST(4) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_FIELD _MK_FIELD_CONST(0x1, PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_SHIFT) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_ON_FLYING _MK_ENUM_CONST(0x0) +#define PDP_D_OPERATION_MODE_CFG_0_FLYING_MODE_OFF_FLYING _MK_ENUM_CONST(0x1) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT _MK_SHIFT_CONST(8) +#define PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_FIELD _MK_FIELD_CONST(0xff, PDP_D_OPERATION_MODE_CFG_0_SPLIT_NUM_SHIFT) + + +// Register PDP_D_NAN_FLUSH_TO_ZERO_0 +#define PDP_D_NAN_FLUSH_TO_ZERO_0 _MK_ADDR_CONST(0xb028) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_FIELD _MK_FIELD_CONST(0x1, PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DISABLE _MK_ENUM_CONST(0x0) +#define PDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_ENABLE _MK_ENUM_CONST(0x1) + + +// Register PDP_D_PARTIAL_WIDTH_IN_0 +#define PDP_D_PARTIAL_WIDTH_IN_0 _MK_ADDR_CONST(0xb02c) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_FIELD _MK_FIELD_CONST(0x3ff, PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_FIRST_SHIFT) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT _MK_SHIFT_CONST(10) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_FIELD _MK_FIELD_CONST(0x3ff, PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_LAST_SHIFT) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT _MK_SHIFT_CONST(20) +#define PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_FIELD _MK_FIELD_CONST(0x3ff, PDP_D_PARTIAL_WIDTH_IN_0_PARTIAL_WIDTH_IN_MID_SHIFT) + + +// Register PDP_D_PARTIAL_WIDTH_OUT_0 +#define PDP_D_PARTIAL_WIDTH_OUT_0 _MK_ADDR_CONST(0xb030) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_FIELD _MK_FIELD_CONST(0x3ff, PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_FIRST_SHIFT) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_SHIFT _MK_SHIFT_CONST(10) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_FIELD _MK_FIELD_CONST(0x3ff, PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_LAST_SHIFT) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_SHIFT _MK_SHIFT_CONST(20) +#define PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_FIELD _MK_FIELD_CONST(0x3ff, PDP_D_PARTIAL_WIDTH_OUT_0_PARTIAL_WIDTH_OUT_MID_SHIFT) + + +// Register PDP_D_POOLING_KERNEL_CFG_0 +#define PDP_D_POOLING_KERNEL_CFG_0 _MK_ADDR_CONST(0xb034) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_FIELD _MK_FIELD_CONST(0xf, PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_SHIFT) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_1 _MK_ENUM_CONST(0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_2 _MK_ENUM_CONST(0x1) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_3 _MK_ENUM_CONST(0x2) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_4 _MK_ENUM_CONST(0x3) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_5 _MK_ENUM_CONST(0x4) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_6 _MK_ENUM_CONST(0x5) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_7 _MK_ENUM_CONST(0x6) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_WIDTH_KERNEL_WIDTH_8 _MK_ENUM_CONST(0x7) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_SHIFT _MK_SHIFT_CONST(8) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_FIELD _MK_FIELD_CONST(0xf, PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_SHIFT) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_1 _MK_ENUM_CONST(0x0) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_2 _MK_ENUM_CONST(0x1) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_3 _MK_ENUM_CONST(0x2) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_4 _MK_ENUM_CONST(0x3) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_5 _MK_ENUM_CONST(0x4) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_6 _MK_ENUM_CONST(0x5) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_7 _MK_ENUM_CONST(0x6) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_HEIGHT_KERNEL_HEIGHT_8 _MK_ENUM_CONST(0x7) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT _MK_SHIFT_CONST(16) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_FIELD _MK_FIELD_CONST(0xf, PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_WIDTH_SHIFT) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_SHIFT _MK_SHIFT_CONST(20) +#define PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_FIELD _MK_FIELD_CONST(0xf, PDP_D_POOLING_KERNEL_CFG_0_KERNEL_STRIDE_HEIGHT_SHIFT) + + +// Register PDP_D_RECIP_KERNEL_WIDTH_0 +#define PDP_D_RECIP_KERNEL_WIDTH_0 _MK_ADDR_CONST(0xb038) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_FIELD _MK_FIELD_CONST(0x1ffff, PDP_D_RECIP_KERNEL_WIDTH_0_RECIP_KERNEL_WIDTH_SHIFT) + + +// Register PDP_D_RECIP_KERNEL_HEIGHT_0 +#define PDP_D_RECIP_KERNEL_HEIGHT_0 _MK_ADDR_CONST(0xb03c) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_FIELD _MK_FIELD_CONST(0x1ffff, PDP_D_RECIP_KERNEL_HEIGHT_0_RECIP_KERNEL_HEIGHT_SHIFT) + + +// Register PDP_D_POOLING_PADDING_CFG_0 +#define PDP_D_POOLING_PADDING_CFG_0 _MK_ADDR_CONST(0xb040) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_FIELD _MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_LEFT_SHIFT) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_SHIFT _MK_SHIFT_CONST(4) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_FIELD _MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_TOP_SHIFT) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_SHIFT _MK_SHIFT_CONST(8) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_FIELD _MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_RIGHT_SHIFT) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_SHIFT _MK_SHIFT_CONST(12) +#define PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_FIELD _MK_FIELD_CONST(0x7, PDP_D_POOLING_PADDING_CFG_0_PAD_BOTTOM_SHIFT) + + +// Register PDP_D_POOLING_PADDING_VALUE_1_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0 _MK_ADDR_CONST(0xb044) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_FIELD _MK_FIELD_CONST(0x7ffff, PDP_D_POOLING_PADDING_VALUE_1_CFG_0_PAD_VALUE_1X_SHIFT) + + +// Register PDP_D_POOLING_PADDING_VALUE_2_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0 _MK_ADDR_CONST(0xb048) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_FIELD _MK_FIELD_CONST(0x7ffff, PDP_D_POOLING_PADDING_VALUE_2_CFG_0_PAD_VALUE_2X_SHIFT) + + +// Register PDP_D_POOLING_PADDING_VALUE_3_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0 _MK_ADDR_CONST(0xb04c) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_FIELD _MK_FIELD_CONST(0x7ffff, PDP_D_POOLING_PADDING_VALUE_3_CFG_0_PAD_VALUE_3X_SHIFT) + + +// Register PDP_D_POOLING_PADDING_VALUE_4_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0 _MK_ADDR_CONST(0xb050) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_FIELD _MK_FIELD_CONST(0x7ffff, PDP_D_POOLING_PADDING_VALUE_4_CFG_0_PAD_VALUE_4X_SHIFT) + + +// Register PDP_D_POOLING_PADDING_VALUE_5_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0 _MK_ADDR_CONST(0xb054) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_FIELD _MK_FIELD_CONST(0x7ffff, PDP_D_POOLING_PADDING_VALUE_5_CFG_0_PAD_VALUE_5X_SHIFT) + + +// Register PDP_D_POOLING_PADDING_VALUE_6_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0 _MK_ADDR_CONST(0xb058) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_FIELD _MK_FIELD_CONST(0x7ffff, PDP_D_POOLING_PADDING_VALUE_6_CFG_0_PAD_VALUE_6X_SHIFT) + + +// Register PDP_D_POOLING_PADDING_VALUE_7_CFG_0 +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0 _MK_ADDR_CONST(0xb05c) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_FIELD _MK_FIELD_CONST(0x7ffff, PDP_D_POOLING_PADDING_VALUE_7_CFG_0_PAD_VALUE_7X_SHIFT) + + +// Register PDP_D_SRC_BASE_ADDR_LOW_0 +#define PDP_D_SRC_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0xb060) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT) + + +// Register PDP_D_SRC_BASE_ADDR_HIGH_0 +#define PDP_D_SRC_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0xb064) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT) + + +// Register PDP_D_SRC_LINE_STRIDE_0 +#define PDP_D_SRC_LINE_STRIDE_0 _MK_ADDR_CONST(0xb068) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT) + + +// Register PDP_D_SRC_SURFACE_STRIDE_0 +#define PDP_D_SRC_SURFACE_STRIDE_0 _MK_ADDR_CONST(0xb06c) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT) + + +// Register PDP_D_DST_BASE_ADDR_LOW_0 +#define PDP_D_DST_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0xb070) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT) + + +// Register PDP_D_DST_BASE_ADDR_HIGH_0 +#define PDP_D_DST_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0xb074) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT) + + +// Register PDP_D_DST_LINE_STRIDE_0 +#define PDP_D_DST_LINE_STRIDE_0 _MK_ADDR_CONST(0xb078) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT) + + +// Register PDP_D_DST_SURFACE_STRIDE_0 +#define PDP_D_DST_SURFACE_STRIDE_0 _MK_ADDR_CONST(0xb07c) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT) + + +// Register PDP_D_DST_RAM_CFG_0 +#define PDP_D_DST_RAM_CFG_0 _MK_ADDR_CONST(0xb080) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_SHIFT) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define PDP_D_DST_RAM_CFG_0_DST_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register PDP_D_DATA_FORMAT_0 +#define PDP_D_DATA_FORMAT_0 _MK_ADDR_CONST(0xb084) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_FIELD _MK_FIELD_CONST(0x3, PDP_D_DATA_FORMAT_0_INPUT_DATA_SHIFT) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_INT8 _MK_ENUM_CONST(0x0) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_INT16 _MK_ENUM_CONST(0x1) +#define PDP_D_DATA_FORMAT_0_INPUT_DATA_FP16 _MK_ENUM_CONST(0x2) + + +// Register PDP_D_INF_INPUT_NUM_0 +#define PDP_D_INF_INPUT_NUM_0 _MK_ADDR_CONST(0xb088) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT) + + +// Register PDP_D_NAN_INPUT_NUM_0 +#define PDP_D_NAN_INPUT_NUM_0 _MK_ADDR_CONST(0xb08c) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT) + + +// Register PDP_D_NAN_OUTPUT_NUM_0 +#define PDP_D_NAN_OUTPUT_NUM_0 _MK_ADDR_CONST(0xb090) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT) + + +// Register PDP_D_PERF_ENABLE_0 +#define PDP_D_PERF_ENABLE_0 _MK_ADDR_CONST(0xb094) +#define PDP_D_PERF_ENABLE_0_DMA_EN_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_PERF_ENABLE_0_DMA_EN_FIELD _MK_FIELD_CONST(0x1, PDP_D_PERF_ENABLE_0_DMA_EN_SHIFT) +#define PDP_D_PERF_ENABLE_0_DMA_EN_DISABLE _MK_ENUM_CONST(0x0) +#define PDP_D_PERF_ENABLE_0_DMA_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register PDP_D_PERF_WRITE_STALL_0 +#define PDP_D_PERF_WRITE_STALL_0 _MK_ADDR_CONST(0xb098) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT) + + +// Register PDP_D_CYA_0 +#define PDP_D_CYA_0 _MK_ADDR_CONST(0xb09c) +#define PDP_D_CYA_0_CYA_SHIFT _MK_SHIFT_CONST(0) +#define PDP_D_CYA_0_CYA_FIELD _MK_FIELD_CONST(0xffffffff, PDP_D_CYA_0_CYA_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register CDP_RDMA_S_STATUS_0 +#define CDP_RDMA_S_STATUS_0 _MK_ADDR_CONST(0xc000) +#define CDP_RDMA_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, CDP_RDMA_S_STATUS_0_STATUS_0_SHIFT) +#define CDP_RDMA_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define CDP_RDMA_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define CDP_RDMA_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define CDP_RDMA_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define CDP_RDMA_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, CDP_RDMA_S_STATUS_0_STATUS_1_SHIFT) +#define CDP_RDMA_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define CDP_RDMA_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define CDP_RDMA_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register CDP_RDMA_S_POINTER_0 +#define CDP_RDMA_S_POINTER_0 _MK_ADDR_CONST(0xc004) +#define CDP_RDMA_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, CDP_RDMA_S_POINTER_0_PRODUCER_SHIFT) +#define CDP_RDMA_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CDP_RDMA_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define CDP_RDMA_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define CDP_RDMA_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, CDP_RDMA_S_POINTER_0_CONSUMER_SHIFT) +#define CDP_RDMA_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CDP_RDMA_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register CDP_RDMA_D_OP_ENABLE_0 +#define CDP_RDMA_D_OP_ENABLE_0 _MK_ADDR_CONST(0xc008) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, CDP_RDMA_D_OP_ENABLE_0_OP_EN_SHIFT) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_RDMA_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_RDMA_D_DATA_CUBE_WIDTH_0 +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0 _MK_ADDR_CONST(0xc00c) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, CDP_RDMA_D_DATA_CUBE_WIDTH_0_WIDTH_SHIFT) + + +// Register CDP_RDMA_D_DATA_CUBE_HEIGHT_0 +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0 _MK_ADDR_CONST(0xc010) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, CDP_RDMA_D_DATA_CUBE_HEIGHT_0_HEIGHT_SHIFT) + + +// Register CDP_RDMA_D_DATA_CUBE_CHANNEL_0 +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0 _MK_ADDR_CONST(0xc014) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, CDP_RDMA_D_DATA_CUBE_CHANNEL_0_CHANNEL_SHIFT) + + +// Register CDP_RDMA_D_SRC_BASE_ADDR_LOW_0 +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0xc018) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_RDMA_D_SRC_BASE_ADDR_LOW_0_SRC_BASE_ADDR_LOW_SHIFT) + + +// Register CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0xc01c) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, CDP_RDMA_D_SRC_BASE_ADDR_HIGH_0_SRC_BASE_ADDR_HIGH_SHIFT) + + +// Register CDP_RDMA_D_SRC_LINE_STRIDE_0 +#define CDP_RDMA_D_SRC_LINE_STRIDE_0 _MK_ADDR_CONST(0xc020) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDP_RDMA_D_SRC_LINE_STRIDE_0_SRC_LINE_STRIDE_SHIFT) + + +// Register CDP_RDMA_D_SRC_SURFACE_STRIDE_0 +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0 _MK_ADDR_CONST(0xc024) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDP_RDMA_D_SRC_SURFACE_STRIDE_0_SRC_SURFACE_STRIDE_SHIFT) + + +// Register CDP_RDMA_D_SRC_DMA_CFG_0 +#define CDP_RDMA_D_SRC_DMA_CFG_0 _MK_ADDR_CONST(0xc028) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_SHIFT) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define CDP_RDMA_D_SRC_DMA_CFG_0_SRC_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register CDP_RDMA_D_SRC_COMPRESSION_EN_0 +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0 _MK_ADDR_CONST(0xc02c) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_FIELD _MK_FIELD_CONST(0x1, CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_SHIFT) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_RDMA_D_SRC_COMPRESSION_EN_0_SRC_COMPRESSION_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_RDMA_D_OPERATION_MODE_0 +#define CDP_RDMA_D_OPERATION_MODE_0 _MK_ADDR_CONST(0xc030) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_FIELD _MK_FIELD_CONST(0x3, CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_SHIFT) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_READPHILE _MK_ENUM_CONST(0x0) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_WRITEPHILE _MK_ENUM_CONST(0x1) +#define CDP_RDMA_D_OPERATION_MODE_0_OPERATION_MODE_ORDINARY _MK_ENUM_CONST(0x2) + + +// Register CDP_RDMA_D_DATA_FORMAT_0 +#define CDP_RDMA_D_DATA_FORMAT_0 _MK_ADDR_CONST(0xc034) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FIELD _MK_FIELD_CONST(0x3, CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_SHIFT) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT8 _MK_ENUM_CONST(0x0) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_INT16 _MK_ENUM_CONST(0x1) +#define CDP_RDMA_D_DATA_FORMAT_0_INPUT_DATA_FP16 _MK_ENUM_CONST(0x2) + + +// Register CDP_RDMA_D_PERF_ENABLE_0 +#define CDP_RDMA_D_PERF_ENABLE_0 _MK_ADDR_CONST(0xc038) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_FIELD _MK_FIELD_CONST(0x1, CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_SHIFT) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_RDMA_D_PERF_ENABLE_0_DMA_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_RDMA_D_PERF_READ_STALL_0 +#define CDP_RDMA_D_PERF_READ_STALL_0 _MK_ADDR_CONST(0xc03c) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_FIELD _MK_FIELD_CONST(0xffffffff, CDP_RDMA_D_PERF_READ_STALL_0_PERF_READ_STALL_SHIFT) + + +// Register CDP_RDMA_D_CYA_0 +#define CDP_RDMA_D_CYA_0 _MK_ADDR_CONST(0xc040) +#define CDP_RDMA_D_CYA_0_CYA_SHIFT _MK_SHIFT_CONST(0) +#define CDP_RDMA_D_CYA_0_CYA_FIELD _MK_FIELD_CONST(0xffffffff, CDP_RDMA_D_CYA_0_CYA_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register CDP_S_STATUS_0 +#define CDP_S_STATUS_0 _MK_ADDR_CONST(0xd000) +#define CDP_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, CDP_S_STATUS_0_STATUS_0_SHIFT) +#define CDP_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define CDP_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define CDP_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define CDP_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define CDP_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, CDP_S_STATUS_0_STATUS_1_SHIFT) +#define CDP_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define CDP_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define CDP_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register CDP_S_POINTER_0 +#define CDP_S_POINTER_0 _MK_ADDR_CONST(0xd004) +#define CDP_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, CDP_S_POINTER_0_PRODUCER_SHIFT) +#define CDP_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CDP_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define CDP_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define CDP_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, CDP_S_POINTER_0_CONSUMER_SHIFT) +#define CDP_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define CDP_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register CDP_S_LUT_ACCESS_CFG_0 +#define CDP_S_LUT_ACCESS_CFG_0 _MK_ADDR_CONST(0xd008) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_FIELD _MK_FIELD_CONST(0x3ff, CDP_S_LUT_ACCESS_CFG_0_LUT_ADDR_SHIFT) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT _MK_SHIFT_CONST(16) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_FIELD _MK_FIELD_CONST(0x1, CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_SHIFT) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LE _MK_ENUM_CONST(0x0) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_TABLE_ID_LO _MK_ENUM_CONST(0x1) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT _MK_SHIFT_CONST(17) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_FIELD _MK_FIELD_CONST(0x1, CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_SHIFT) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_READ _MK_ENUM_CONST(0x0) +#define CDP_S_LUT_ACCESS_CFG_0_LUT_ACCESS_TYPE_WRITE _MK_ENUM_CONST(0x1) + + +// Register CDP_S_LUT_ACCESS_DATA_0 +#define CDP_S_LUT_ACCESS_DATA_0 _MK_ADDR_CONST(0xd00c) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_FIELD _MK_FIELD_CONST(0xffff, CDP_S_LUT_ACCESS_DATA_0_LUT_DATA_SHIFT) + + +// Register CDP_S_LUT_CFG_0 +#define CDP_S_LUT_CFG_0 _MK_ADDR_CONST(0xd010) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_FIELD _MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_SHIFT) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_EXPONENT _MK_ENUM_CONST(0x0) +#define CDP_S_LUT_CFG_0_LUT_LE_FUNCTION_LINEAR _MK_ENUM_CONST(0x1) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT _MK_SHIFT_CONST(4) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_FIELD _MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_SHIFT) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LE _MK_ENUM_CONST(0x0) +#define CDP_S_LUT_CFG_0_LUT_UFLOW_PRIORITY_LO _MK_ENUM_CONST(0x1) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT _MK_SHIFT_CONST(5) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_FIELD _MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_SHIFT) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LE _MK_ENUM_CONST(0x0) +#define CDP_S_LUT_CFG_0_LUT_OFLOW_PRIORITY_LO _MK_ENUM_CONST(0x1) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT _MK_SHIFT_CONST(6) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_FIELD _MK_FIELD_CONST(0x1, CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_SHIFT) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LE _MK_ENUM_CONST(0x0) +#define CDP_S_LUT_CFG_0_LUT_HYBRID_PRIORITY_LO _MK_ENUM_CONST(0x1) + + +// Register CDP_S_LUT_INFO_0 +#define CDP_S_LUT_INFO_0 _MK_ADDR_CONST(0xd014) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_FIELD _MK_FIELD_CONST(0xff, CDP_S_LUT_INFO_0_LUT_LE_INDEX_OFFSET_SHIFT) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT _MK_SHIFT_CONST(8) +#define CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_FIELD _MK_FIELD_CONST(0xff, CDP_S_LUT_INFO_0_LUT_LE_INDEX_SELECT_SHIFT) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT _MK_SHIFT_CONST(16) +#define CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_FIELD _MK_FIELD_CONST(0xff, CDP_S_LUT_INFO_0_LUT_LO_INDEX_SELECT_SHIFT) + + +// Register CDP_S_LUT_LE_START_LOW_0 +#define CDP_S_LUT_LE_START_LOW_0 _MK_ADDR_CONST(0xd018) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_S_LUT_LE_START_LOW_0_LUT_LE_START_LOW_SHIFT) + + +// Register CDP_S_LUT_LE_START_HIGH_0 +#define CDP_S_LUT_LE_START_HIGH_0 _MK_ADDR_CONST(0xd01c) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_FIELD _MK_FIELD_CONST(0x3f, CDP_S_LUT_LE_START_HIGH_0_LUT_LE_START_HIGH_SHIFT) + + +// Register CDP_S_LUT_LE_END_LOW_0 +#define CDP_S_LUT_LE_END_LOW_0 _MK_ADDR_CONST(0xd020) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_S_LUT_LE_END_LOW_0_LUT_LE_END_LOW_SHIFT) + + +// Register CDP_S_LUT_LE_END_HIGH_0 +#define CDP_S_LUT_LE_END_HIGH_0 _MK_ADDR_CONST(0xd024) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_FIELD _MK_FIELD_CONST(0x3f, CDP_S_LUT_LE_END_HIGH_0_LUT_LE_END_HIGH_SHIFT) + + +// Register CDP_S_LUT_LO_START_LOW_0 +#define CDP_S_LUT_LO_START_LOW_0 _MK_ADDR_CONST(0xd028) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_S_LUT_LO_START_LOW_0_LUT_LO_START_LOW_SHIFT) + + +// Register CDP_S_LUT_LO_START_HIGH_0 +#define CDP_S_LUT_LO_START_HIGH_0 _MK_ADDR_CONST(0xd02c) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_FIELD _MK_FIELD_CONST(0x3f, CDP_S_LUT_LO_START_HIGH_0_LUT_LO_START_HIGH_SHIFT) + + +// Register CDP_S_LUT_LO_END_LOW_0 +#define CDP_S_LUT_LO_END_LOW_0 _MK_ADDR_CONST(0xd030) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_S_LUT_LO_END_LOW_0_LUT_LO_END_LOW_SHIFT) + + +// Register CDP_S_LUT_LO_END_HIGH_0 +#define CDP_S_LUT_LO_END_HIGH_0 _MK_ADDR_CONST(0xd034) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_FIELD _MK_FIELD_CONST(0x3f, CDP_S_LUT_LO_END_HIGH_0_LUT_LO_END_HIGH_SHIFT) + + +// Register CDP_S_LUT_LE_SLOPE_SCALE_0 +#define CDP_S_LUT_LE_SLOPE_SCALE_0 _MK_ADDR_CONST(0xd038) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_UFLOW_SCALE_SHIFT) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT _MK_SHIFT_CONST(16) +#define CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, CDP_S_LUT_LE_SLOPE_SCALE_0_LUT_LE_SLOPE_OFLOW_SCALE_SHIFT) + + +// Register CDP_S_LUT_LE_SLOPE_SHIFT_0 +#define CDP_S_LUT_LE_SLOPE_SHIFT_0 _MK_ADDR_CONST(0xd03c) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_UFLOW_SHIFT_SHIFT) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(5) +#define CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, CDP_S_LUT_LE_SLOPE_SHIFT_0_LUT_LE_SLOPE_OFLOW_SHIFT_SHIFT) + + +// Register CDP_S_LUT_LO_SLOPE_SCALE_0 +#define CDP_S_LUT_LO_SLOPE_SCALE_0 _MK_ADDR_CONST(0xd040) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_UFLOW_SCALE_SHIFT) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT _MK_SHIFT_CONST(16) +#define CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_FIELD _MK_FIELD_CONST(0xffff, CDP_S_LUT_LO_SLOPE_SCALE_0_LUT_LO_SLOPE_OFLOW_SCALE_SHIFT) + + +// Register CDP_S_LUT_LO_SLOPE_SHIFT_0 +#define CDP_S_LUT_LO_SLOPE_SHIFT_0 _MK_ADDR_CONST(0xd044) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(0) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_UFLOW_SHIFT_SHIFT) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT _MK_SHIFT_CONST(5) +#define CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_FIELD _MK_FIELD_CONST(0x1f, CDP_S_LUT_LO_SLOPE_SHIFT_0_LUT_LO_SLOPE_OFLOW_SHIFT_SHIFT) + + +// Register CDP_D_OP_ENABLE_0 +#define CDP_D_OP_ENABLE_0 _MK_ADDR_CONST(0xd048) +#define CDP_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, CDP_D_OP_ENABLE_0_OP_EN_SHIFT) +#define CDP_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_D_FUNC_BYPASS_0 +#define CDP_D_FUNC_BYPASS_0 _MK_ADDR_CONST(0xd04c) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_FIELD _MK_FIELD_CONST(0x1, CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_SHIFT) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_D_FUNC_BYPASS_0_SQSUM_BYPASS_ENABLE _MK_ENUM_CONST(0x1) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_SHIFT _MK_SHIFT_CONST(1) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_FIELD _MK_FIELD_CONST(0x1, CDP_D_FUNC_BYPASS_0_MUL_BYPASS_SHIFT) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_D_FUNC_BYPASS_0_MUL_BYPASS_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_D_DST_BASE_ADDR_LOW_0 +#define CDP_D_DST_BASE_ADDR_LOW_0 _MK_ADDR_CONST(0xd050) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_DST_BASE_ADDR_LOW_0_DST_BASE_ADDR_LOW_SHIFT) + + +// Register CDP_D_DST_BASE_ADDR_HIGH_0 +#define CDP_D_DST_BASE_ADDR_HIGH_0 _MK_ADDR_CONST(0xd054) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_DST_BASE_ADDR_HIGH_0_DST_BASE_ADDR_HIGH_SHIFT) + + +// Register CDP_D_DST_LINE_STRIDE_0 +#define CDP_D_DST_LINE_STRIDE_0 _MK_ADDR_CONST(0xd058) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_DST_LINE_STRIDE_0_DST_LINE_STRIDE_SHIFT) + + +// Register CDP_D_DST_SURFACE_STRIDE_0 +#define CDP_D_DST_SURFACE_STRIDE_0 _MK_ADDR_CONST(0xd05c) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_DST_SURFACE_STRIDE_0_DST_SURFACE_STRIDE_SHIFT) + + +// Register CDP_D_DST_DMA_CFG_0 +#define CDP_D_DST_DMA_CFG_0 _MK_ADDR_CONST(0xd060) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_SHIFT) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_CV _MK_ENUM_CONST(0x0) +#define CDP_D_DST_DMA_CFG_0_DST_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register CDP_D_DST_COMPRESSION_EN_0 +#define CDP_D_DST_COMPRESSION_EN_0 _MK_ADDR_CONST(0xd064) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_FIELD _MK_FIELD_CONST(0x1, CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_SHIFT) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_D_DST_COMPRESSION_EN_0_DST_COMPRESSION_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_D_DATA_FORMAT_0 +#define CDP_D_DATA_FORMAT_0 _MK_ADDR_CONST(0xd068) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_FIELD _MK_FIELD_CONST(0x3, CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_SHIFT) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_INT8 _MK_ENUM_CONST(0x0) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_INT16 _MK_ENUM_CONST(0x1) +#define CDP_D_DATA_FORMAT_0_INPUT_DATA_TYPE_FP16 _MK_ENUM_CONST(0x2) + + +// Register CDP_D_NAN_FLUSH_TO_ZERO_0 +#define CDP_D_NAN_FLUSH_TO_ZERO_0 _MK_ADDR_CONST(0xd06c) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_FIELD _MK_FIELD_CONST(0x1, CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_SHIFT) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_D_NAN_FLUSH_TO_ZERO_0_NAN_TO_ZERO_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_D_LRN_CFG_0 +#define CDP_D_LRN_CFG_0 _MK_ADDR_CONST(0xd070) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_FIELD _MK_FIELD_CONST(0x3, CDP_D_LRN_CFG_0_NORMALZ_LEN_SHIFT) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN3 _MK_ENUM_CONST(0x0) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN5 _MK_ENUM_CONST(0x1) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN7 _MK_ENUM_CONST(0x2) +#define CDP_D_LRN_CFG_0_NORMALZ_LEN_LEN9 _MK_ENUM_CONST(0x3) + + +// Register CDP_D_DATIN_OFFSET_0 +#define CDP_D_DATIN_OFFSET_0 _MK_ADDR_CONST(0xd074) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_FIELD _MK_FIELD_CONST(0xffff, CDP_D_DATIN_OFFSET_0_DATIN_OFFSET_SHIFT) + + +// Register CDP_D_DATIN_SCALE_0 +#define CDP_D_DATIN_SCALE_0 _MK_ADDR_CONST(0xd078) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DATIN_SCALE_0_DATIN_SCALE_FIELD _MK_FIELD_CONST(0xffff, CDP_D_DATIN_SCALE_0_DATIN_SCALE_SHIFT) + + +// Register CDP_D_DATIN_SHIFTER_0 +#define CDP_D_DATIN_SHIFTER_0 _MK_ADDR_CONST(0xd07c) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_FIELD _MK_FIELD_CONST(0x1f, CDP_D_DATIN_SHIFTER_0_DATIN_SHIFTER_SHIFT) + + +// Register CDP_D_DATOUT_OFFSET_0 +#define CDP_D_DATOUT_OFFSET_0 _MK_ADDR_CONST(0xd080) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_DATOUT_OFFSET_0_DATOUT_OFFSET_SHIFT) + + +// Register CDP_D_DATOUT_SCALE_0 +#define CDP_D_DATOUT_SCALE_0 _MK_ADDR_CONST(0xd084) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_FIELD _MK_FIELD_CONST(0xffff, CDP_D_DATOUT_SCALE_0_DATOUT_SCALE_SHIFT) + + +// Register CDP_D_DATOUT_SHIFTER_0 +#define CDP_D_DATOUT_SHIFTER_0 _MK_ADDR_CONST(0xd088) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_FIELD _MK_FIELD_CONST(0x3f, CDP_D_DATOUT_SHIFTER_0_DATOUT_SHIFTER_SHIFT) + + +// Register CDP_D_NAN_INPUT_NUM_0 +#define CDP_D_NAN_INPUT_NUM_0 _MK_ADDR_CONST(0xd08c) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_NAN_INPUT_NUM_0_NAN_INPUT_NUM_SHIFT) + + +// Register CDP_D_INF_INPUT_NUM_0 +#define CDP_D_INF_INPUT_NUM_0 _MK_ADDR_CONST(0xd090) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_INF_INPUT_NUM_0_INF_INPUT_NUM_SHIFT) + + +// Register CDP_D_NAN_OUTPUT_NUM_0 +#define CDP_D_NAN_OUTPUT_NUM_0 _MK_ADDR_CONST(0xd094) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_NAN_OUTPUT_NUM_0_NAN_OUTPUT_NUM_SHIFT) + + +// Register CDP_D_OUT_SATURATION_0 +#define CDP_D_OUT_SATURATION_0 _MK_ADDR_CONST(0xd098) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_OUT_SATURATION_0_OUT_SATURATION_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_OUT_SATURATION_0_OUT_SATURATION_SHIFT) + + +// Register CDP_D_PERF_ENABLE_0 +#define CDP_D_PERF_ENABLE_0 _MK_ADDR_CONST(0xd09c) +#define CDP_D_PERF_ENABLE_0_DMA_EN_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_PERF_ENABLE_0_DMA_EN_FIELD _MK_FIELD_CONST(0x1, CDP_D_PERF_ENABLE_0_DMA_EN_SHIFT) +#define CDP_D_PERF_ENABLE_0_DMA_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_D_PERF_ENABLE_0_DMA_EN_ENABLE _MK_ENUM_CONST(0x1) +#define CDP_D_PERF_ENABLE_0_LUT_EN_SHIFT _MK_SHIFT_CONST(1) +#define CDP_D_PERF_ENABLE_0_LUT_EN_FIELD _MK_FIELD_CONST(0x1, CDP_D_PERF_ENABLE_0_LUT_EN_SHIFT) +#define CDP_D_PERF_ENABLE_0_LUT_EN_DISABLE _MK_ENUM_CONST(0x0) +#define CDP_D_PERF_ENABLE_0_LUT_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register CDP_D_PERF_WRITE_STALL_0 +#define CDP_D_PERF_WRITE_STALL_0 _MK_ADDR_CONST(0xd0a0) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_PERF_WRITE_STALL_0_PERF_WRITE_STALL_SHIFT) + + +// Register CDP_D_PERF_LUT_UFLOW_0 +#define CDP_D_PERF_LUT_UFLOW_0 _MK_ADDR_CONST(0xd0a4) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_PERF_LUT_UFLOW_0_PERF_LUT_UFLOW_SHIFT) + + +// Register CDP_D_PERF_LUT_OFLOW_0 +#define CDP_D_PERF_LUT_OFLOW_0 _MK_ADDR_CONST(0xd0a8) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_PERF_LUT_OFLOW_0_PERF_LUT_OFLOW_SHIFT) + + +// Register CDP_D_PERF_LUT_HYBRID_0 +#define CDP_D_PERF_LUT_HYBRID_0 _MK_ADDR_CONST(0xd0ac) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_PERF_LUT_HYBRID_0_PERF_LUT_HYBRID_SHIFT) + + +// Register CDP_D_PERF_LUT_LE_HIT_0 +#define CDP_D_PERF_LUT_LE_HIT_0 _MK_ADDR_CONST(0xd0b0) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_PERF_LUT_LE_HIT_0_PERF_LUT_LE_HIT_SHIFT) + + +// Register CDP_D_PERF_LUT_LO_HIT_0 +#define CDP_D_PERF_LUT_LO_HIT_0 _MK_ADDR_CONST(0xd0b4) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_PERF_LUT_LO_HIT_0_PERF_LUT_LO_HIT_SHIFT) + + +// Register CDP_D_CYA_0 +#define CDP_D_CYA_0 _MK_ADDR_CONST(0xd0b8) +#define CDP_D_CYA_0_CYA_SHIFT _MK_SHIFT_CONST(0) +#define CDP_D_CYA_0_CYA_FIELD _MK_FIELD_CONST(0xffffffff, CDP_D_CYA_0_CYA_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register NVDLA_GEC_FEATURE_0 +#define NVDLA_GEC_FEATURE_0 _MK_ADDR_CONST(0xe000) +#define NVDLA_GEC_FEATURE_0_NUM_ERR_SLICES_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_FEATURE_0_NUM_ERR_SLICES_FIELD _MK_FIELD_CONST(0x3f, NVDLA_GEC_FEATURE_0_NUM_ERR_SLICES_SHIFT) +#define NVDLA_GEC_FEATURE_0_NUM_ERR_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_FEATURE_0_NUM_ERR_FIELD _MK_FIELD_CONST(0xffff, NVDLA_GEC_FEATURE_0_NUM_ERR_SHIFT) + + +// Register NVDLA_GEC_SWRESET_0 +#define NVDLA_GEC_SWRESET_0 _MK_ADDR_CONST(0xe004) +#define NVDLA_GEC_SWRESET_0_SWRST_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_SWRESET_0_SWRST_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_SWRESET_0_SWRST_SHIFT) + + +// Register NVDLA_GEC_MISSIONERR_TYPE_0 +#define NVDLA_GEC_MISSIONERR_TYPE_0 _MK_ADDR_CONST(0xe008) +#define NVDLA_GEC_MISSIONERR_TYPE_0_CODE_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_MISSIONERR_TYPE_0_CODE_FIELD _MK_FIELD_CONST(0x3f, NVDLA_GEC_MISSIONERR_TYPE_0_CODE_SHIFT) + + +// Register NVDLA_GEC_CURRENT_COUNTER_VALUE_0 +#define NVDLA_GEC_CURRENT_COUNTER_VALUE_0 _MK_ADDR_CONST(0xe00c) +#define NVDLA_GEC_CURRENT_COUNTER_VALUE_0_VALUE_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_CURRENT_COUNTER_VALUE_0_VALUE_FIELD _MK_FIELD_CONST(0x1ff, NVDLA_GEC_CURRENT_COUNTER_VALUE_0_VALUE_SHIFT) + + +// Register NVDLA_GEC_MISSIONERR_INDEX_0 +#define NVDLA_GEC_MISSIONERR_INDEX_0 _MK_ADDR_CONST(0xe014) +#define NVDLA_GEC_MISSIONERR_INDEX_0_IDX_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_MISSIONERR_INDEX_0_IDX_FIELD _MK_FIELD_CONST(0x7f, NVDLA_GEC_MISSIONERR_INDEX_0_IDX_SHIFT) + + +// Register NVDLA_GEC_CORRECTABLE_THRESHOLD_0 +#define NVDLA_GEC_CORRECTABLE_THRESHOLD_0 _MK_ADDR_CONST(0xe018) +#define NVDLA_GEC_CORRECTABLE_THRESHOLD_0_COUNT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_CORRECTABLE_THRESHOLD_0_COUNT_FIELD _MK_FIELD_CONST(0xff, NVDLA_GEC_CORRECTABLE_THRESHOLD_0_COUNT_SHIFT) + + +// Register NVDLA_GEC_MISSIONERR_INJECT_UNLOCK_0 +#define NVDLA_GEC_MISSIONERR_INJECT_UNLOCK_0 _MK_ADDR_CONST(0xe01c) +#define NVDLA_GEC_MISSIONERR_INJECT_UNLOCK_0_VALUE_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_MISSIONERR_INJECT_UNLOCK_0_VALUE_FIELD _MK_FIELD_CONST(0xff, NVDLA_GEC_MISSIONERR_INJECT_UNLOCK_0_VALUE_SHIFT) +#define NVDLA_GEC_MISSIONERR_INJECT_UNLOCK_0_VALUE_LOCK _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_MISSIONERR_INJECT_UNLOCK_0_VALUE_UNLOCK _MK_ENUM_CONST(0xe1) + + +// Register NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0 +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0 _MK_ADDR_CONST(0xe030) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR0_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR0_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR1_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR1_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR2_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR2_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR3_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR3_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR4_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR4_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR5_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR5_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR6_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR6_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR7_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR7_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR8_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR8_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR9_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR9_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR9_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR9_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR9_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR10_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR10_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR10_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR10_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR10_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR11_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR11_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR11_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR11_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR11_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR12_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR12_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR12_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR12_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR12_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR13_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR13_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR13_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR13_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR13_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR14_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR14_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR14_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR14_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR14_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR15_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR15_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR16_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR16_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR17_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR17_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR18_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR18_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR19_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR19_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR20_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR20_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR21_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR21_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR22_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR22_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR23_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR23_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR24_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR24_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR25_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR25_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR26_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR26_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR27_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR27_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR28_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR28_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR29_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR29_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR30_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR30_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR31_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR31_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_ENABLE_0_ERR31_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0 +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0 _MK_ADDR_CONST(0xe034) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR0_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR0_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR1_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR1_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR2_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR2_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR3_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR3_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR4_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR4_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR5_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR5_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR6_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR6_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR7_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR7_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR8_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR8_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR9_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR9_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR9_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR9_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR9_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR10_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR10_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR10_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR10_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR10_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR11_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR11_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR11_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR11_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR11_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR12_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR12_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR12_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR12_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR12_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR13_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR13_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR13_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR13_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR13_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR14_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR14_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR14_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR14_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR14_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR15_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR15_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR16_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR16_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR17_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR17_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR18_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR18_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR19_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR19_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR20_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR20_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR21_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR21_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR22_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR22_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR23_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR23_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR24_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR24_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR25_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR25_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR26_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR26_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR27_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR27_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR28_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR28_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR29_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR29_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR30_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR30_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR31_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR31_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_FORCE_0_ERR31_FORCE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0 +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0 _MK_ADDR_CONST(0xe038) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR9_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR9_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR9_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR10_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR10_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR10_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR11_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR11_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR11_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR12_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR12_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR12_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR13_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR13_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR13_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR14_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR14_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR14_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_STATUS_0_ERR31_SHIFT) + + +// Register NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0 +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0 _MK_ADDR_CONST(0xe03c) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR0_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR0_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR1_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR1_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR2_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR2_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR3_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR3_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR4_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR4_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR5_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR5_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR6_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR6_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR7_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR7_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR8_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR8_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR15_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR15_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR16_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR16_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR17_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR17_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR18_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR18_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR19_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR19_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR20_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR20_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR21_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR21_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR22_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR22_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR23_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR23_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR24_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR24_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR25_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR25_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR26_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR26_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR27_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR27_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR28_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR28_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR29_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR29_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR30_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR30_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR31_SHIFT) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR31_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_MISSIONERR_INJECT_0_ERR31_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0 +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0 _MK_ADDR_CONST(0xe040) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR0_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR0_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR1_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR1_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR2_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR2_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR3_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR3_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR4_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR4_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR5_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR5_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR6_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR6_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR7_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR7_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR8_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR8_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR9_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR9_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR9_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR9_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR9_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR10_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR10_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR10_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR10_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR10_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR11_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR11_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR11_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR11_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR11_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR12_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR12_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR12_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR12_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR12_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR13_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR13_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR13_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR13_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR13_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR14_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR14_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR14_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR14_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR14_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR15_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR15_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR16_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR16_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR17_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR17_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR18_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR18_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR19_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR19_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR20_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR20_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR21_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR21_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR22_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR22_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR23_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR23_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR24_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR24_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR25_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR25_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR26_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR26_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR27_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR27_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR28_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR28_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR29_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR29_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR30_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR30_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR31_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR31_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_ENABLE_0_ERR31_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0 +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0 _MK_ADDR_CONST(0xe044) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR0_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR0_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR1_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR1_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR2_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR2_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR3_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR3_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR4_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR4_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR5_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR5_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR6_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR6_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR7_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR7_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR8_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR8_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR9_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR9_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR9_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR9_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR9_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR10_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR10_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR10_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR10_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR10_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR11_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR11_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR11_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR11_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR11_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR12_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR12_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR12_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR12_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR12_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR13_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR13_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR13_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR13_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR13_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR14_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR14_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR14_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR14_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR14_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR15_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR15_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR16_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR16_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR17_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR17_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR18_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR18_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR19_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR19_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR20_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR20_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR21_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR21_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR22_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR22_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR23_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR23_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR24_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR24_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR25_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR25_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR26_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR26_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR27_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR27_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR28_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR28_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR29_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR29_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR30_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR30_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR31_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR31_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_FORCE_0_ERR31_FORCE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0 +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0 _MK_ADDR_CONST(0xe048) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR9_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR9_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR9_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR10_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR10_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR10_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR11_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR11_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR11_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR12_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR12_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR12_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR13_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR13_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR13_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR14_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR14_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR14_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_LATENTERR_STATUS_0_ERR31_SHIFT) + + +// Register NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0 +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0 _MK_ADDR_CONST(0xe050) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR0_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR0_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR0_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR0_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR0_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR1_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR1_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR1_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR1_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR1_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR2_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR2_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR2_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR2_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR2_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR3_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR3_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR3_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR3_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR3_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR4_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR4_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR4_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR4_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR4_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR5_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR5_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR5_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR5_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR5_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR6_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR6_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR6_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR6_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR6_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR7_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR7_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR7_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR7_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR7_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR8_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR8_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR8_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR8_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR8_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR9_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR9_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR9_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR9_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR9_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR10_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR10_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR10_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR10_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR10_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR11_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR11_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR11_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR11_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR11_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR12_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR12_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR12_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR12_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR12_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR13_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR13_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR13_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR13_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR13_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR14_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR14_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR14_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR14_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR14_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR15_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR15_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR15_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR15_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR15_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR16_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR16_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR16_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR16_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR16_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR17_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR17_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR17_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR17_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR17_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR18_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR18_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR18_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR18_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR18_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR19_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR19_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR19_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR19_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR19_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR20_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR20_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR20_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR20_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR20_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR21_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR21_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR21_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR21_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR21_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR22_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR22_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR22_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR22_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR22_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR23_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR23_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR23_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR23_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR23_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR24_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR24_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR24_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR24_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR24_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR25_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR25_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR25_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR25_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR25_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR26_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR26_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR26_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR26_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR26_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR27_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR27_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR27_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR27_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR27_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR28_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR28_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR28_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR28_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR28_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR29_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR29_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR29_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR29_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR29_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR30_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR30_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR30_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR30_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR30_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR31_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR31_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR31_SHIFT) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR31_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE0_COUNTER_RELOAD_0_ERR31_RELOAD _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0 +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0 _MK_ADDR_CONST(0xe060) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR32_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR32_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR33_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR33_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR34_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR34_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR35_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR35_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR36_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR36_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR37_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR37_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR38_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR38_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR39_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR39_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR40_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR40_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR41_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR41_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR42_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR42_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR43_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR43_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR44_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR44_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR45_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR45_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR46_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR46_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR47_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR47_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR48_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR48_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR49_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR49_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR50_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR50_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR51_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR51_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR52_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR52_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR53_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR53_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR54_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR54_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR55_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR55_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR56_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR56_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR57_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR57_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR58_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR58_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR59_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR59_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR60_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR60_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR61_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR61_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR62_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR62_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR63_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR63_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ENABLE_0_ERR63_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0 +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0 _MK_ADDR_CONST(0xe064) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR32_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR32_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR33_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR33_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR34_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR34_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR35_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR35_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR36_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR36_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR37_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR37_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR38_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR38_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR39_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR39_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR40_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR40_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR41_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR41_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR42_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR42_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR43_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR43_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR44_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR44_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR45_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR45_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR46_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR46_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR47_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR47_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR48_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR48_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR49_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR49_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR50_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR50_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR51_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR51_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR52_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR52_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR53_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR53_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR54_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR54_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR55_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR55_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR56_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR56_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR57_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR57_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR58_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR58_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR59_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR59_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR60_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR60_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR61_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR61_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR62_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR62_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR63_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR63_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_FORCE_0_ERR63_FORCE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0 +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0 _MK_ADDR_CONST(0xe068) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_STATUS_0_ERR63_SHIFT) + + +// Register NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0 +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0 _MK_ADDR_CONST(0xe06c) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR32_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR32_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR33_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR33_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR34_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR34_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR35_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR35_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR36_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR36_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR37_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR37_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR38_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR38_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR39_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR39_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR40_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR40_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR41_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR41_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR42_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR42_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR43_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR43_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR44_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR44_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR45_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR45_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR46_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR46_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR47_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR47_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR48_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR48_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR49_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR49_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR50_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR50_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR51_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR51_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR52_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR52_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR53_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR53_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR54_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR54_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR55_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR55_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR56_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR56_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR57_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR57_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR58_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR58_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR59_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR59_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR60_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR60_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR61_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR61_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR62_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR62_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR63_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR63_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_INJECT_0_ERR63_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0 +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0 _MK_ADDR_CONST(0xe070) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR32_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR32_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR33_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR33_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR34_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR34_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR35_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR35_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR36_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR36_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR37_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR37_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR38_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR38_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR39_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR39_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR40_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR40_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR41_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR41_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR42_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR42_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR43_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR43_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR44_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR44_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR45_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR45_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR46_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR46_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR47_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR47_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR48_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR48_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR49_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR49_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR50_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR50_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR51_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR51_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR52_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR52_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR53_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR53_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR54_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR54_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR55_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR55_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR56_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR56_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR57_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR57_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR58_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR58_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR59_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR59_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR60_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR60_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR61_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR61_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR62_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR62_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR63_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR63_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_ENABLE_0_ERR63_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0 +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0 _MK_ADDR_CONST(0xe074) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR32_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR32_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR33_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR33_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR34_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR34_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR35_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR35_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR36_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR36_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR37_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR37_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR38_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR38_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR39_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR39_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR40_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR40_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR41_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR41_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR42_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR42_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR43_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR43_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR44_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR44_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR45_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR45_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR46_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR46_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR47_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR47_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR48_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR48_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR49_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR49_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR50_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR50_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR51_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR51_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR52_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR52_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR53_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR53_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR54_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR54_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR55_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR55_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR56_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR56_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR57_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR57_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR58_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR58_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR59_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR59_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR60_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR60_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR61_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR61_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR62_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR62_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR63_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR63_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_FORCE_0_ERR63_FORCE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0 +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0 _MK_ADDR_CONST(0xe078) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_LATENTERR_STATUS_0_ERR63_SHIFT) + + +// Register NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0 +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0 _MK_ADDR_CONST(0xe080) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR32_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR32_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR32_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR32_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR32_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR33_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR33_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR33_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR33_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR33_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR34_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR34_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR34_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR34_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR34_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR35_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR35_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR35_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR35_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR35_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR36_SHIFT _MK_SHIFT_CONST(4) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR36_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR36_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR36_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR36_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR37_SHIFT _MK_SHIFT_CONST(5) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR37_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR37_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR37_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR37_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR38_SHIFT _MK_SHIFT_CONST(6) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR38_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR38_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR38_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR38_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR39_SHIFT _MK_SHIFT_CONST(7) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR39_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR39_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR39_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR39_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR40_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR40_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR40_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR40_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR40_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR41_SHIFT _MK_SHIFT_CONST(9) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR41_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR41_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR41_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR41_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR42_SHIFT _MK_SHIFT_CONST(10) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR42_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR42_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR42_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR42_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR43_SHIFT _MK_SHIFT_CONST(11) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR43_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR43_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR43_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR43_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR44_SHIFT _MK_SHIFT_CONST(12) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR44_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR44_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR44_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR44_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR45_SHIFT _MK_SHIFT_CONST(13) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR45_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR45_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR45_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR45_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR46_SHIFT _MK_SHIFT_CONST(14) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR46_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR46_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR46_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR46_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR47_SHIFT _MK_SHIFT_CONST(15) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR47_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR47_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR47_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR47_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR48_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR48_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR48_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR48_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR48_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR49_SHIFT _MK_SHIFT_CONST(17) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR49_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR49_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR49_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR49_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR50_SHIFT _MK_SHIFT_CONST(18) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR50_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR50_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR50_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR50_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR51_SHIFT _MK_SHIFT_CONST(19) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR51_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR51_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR51_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR51_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR52_SHIFT _MK_SHIFT_CONST(20) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR52_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR52_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR52_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR52_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR53_SHIFT _MK_SHIFT_CONST(21) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR53_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR53_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR53_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR53_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR54_SHIFT _MK_SHIFT_CONST(22) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR54_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR54_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR54_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR54_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR55_SHIFT _MK_SHIFT_CONST(23) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR55_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR55_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR55_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR55_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR56_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR56_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR56_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR56_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR56_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR57_SHIFT _MK_SHIFT_CONST(25) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR57_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR57_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR57_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR57_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR58_SHIFT _MK_SHIFT_CONST(26) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR58_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR58_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR58_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR58_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR59_SHIFT _MK_SHIFT_CONST(27) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR59_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR59_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR59_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR59_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR60_SHIFT _MK_SHIFT_CONST(28) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR60_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR60_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR60_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR60_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR61_SHIFT _MK_SHIFT_CONST(29) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR61_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR61_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR61_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR61_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR62_SHIFT _MK_SHIFT_CONST(30) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR62_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR62_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR62_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR62_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR63_SHIFT) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR63_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_COUNTER_RELOAD_0_ERR63_RELOAD _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE1_MISSIONERR_ECC_CORRECTION_DIS_0 +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ECC_CORRECTION_DIS_0 _MK_ADDR_CONST(0xe084) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ECC_CORRECTION_DIS_0_ERR63_SHIFT _MK_SHIFT_CONST(31) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ECC_CORRECTION_DIS_0_ERR63_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE1_MISSIONERR_ECC_CORRECTION_DIS_0_ERR63_SHIFT) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ECC_CORRECTION_DIS_0_ERR63_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE1_MISSIONERR_ECC_CORRECTION_DIS_0_ERR63_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0 +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0 _MK_ADDR_CONST(0xe090) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR64_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR64_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR65_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR65_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR66_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR66_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR66_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR66_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR66_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR67_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR67_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR67_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR67_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_ENABLE_0_ERR67_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0 +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0 _MK_ADDR_CONST(0xe094) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR64_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR64_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR65_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR65_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR66_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR66_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR66_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR66_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR66_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR67_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR67_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR67_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR67_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_FORCE_0_ERR67_FORCE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0 +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0 _MK_ADDR_CONST(0xe098) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR66_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR66_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR66_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR67_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR67_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_STATUS_0_ERR67_SHIFT) + + +// Register NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0 +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0 _MK_ADDR_CONST(0xe09c) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR64_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR64_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR65_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_MISSIONERR_INJECT_0_ERR65_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0 +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0 _MK_ADDR_CONST(0xe0a0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR64_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR64_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR65_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR65_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR66_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR66_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR66_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR66_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR66_ENABLE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR67_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR67_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR67_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR67_DISABLE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_ENABLE_0_ERR67_ENABLE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0 +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0 _MK_ADDR_CONST(0xe0a4) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR64_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR64_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR65_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR65_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR66_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR66_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR66_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR66_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR66_FORCE _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR67_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR67_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR67_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR67_NOFORCE _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_FORCE_0_ERR67_FORCE _MK_ENUM_CONST(0x1) + + +// Register NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0 +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0 _MK_ADDR_CONST(0xe0a8) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR66_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR66_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR66_SHIFT) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR67_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR67_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_LATENTERR_STATUS_0_ERR67_SHIFT) + + +// Register NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0 +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0 _MK_ADDR_CONST(0xe0b0) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR64_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR64_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR64_SHIFT) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR64_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR64_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR65_SHIFT _MK_SHIFT_CONST(1) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR65_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR65_SHIFT) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR65_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR65_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR66_SHIFT _MK_SHIFT_CONST(2) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR66_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR66_SHIFT) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR66_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR66_RELOAD _MK_ENUM_CONST(0x1) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR67_SHIFT _MK_SHIFT_CONST(3) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR67_FIELD _MK_FIELD_CONST(0x1, NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR67_SHIFT) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR67_NORELOAD _MK_ENUM_CONST(0x0) +#define NVDLA_GEC_ERRSLICE2_COUNTER_RELOAD_0_ERR67_RELOAD _MK_ENUM_CONST(0x1) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register NVDLA_CVIF_CFG_RD_WEIGHT_0_0 +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0 _MK_ADDR_CONST(0xf000) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_BDMA_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_SDP_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_PDP_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_0_0_RD_WEIGHT_CDP_SHIFT) + + +// Register NVDLA_CVIF_CFG_RD_WEIGHT_1_0 +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0 _MK_ADDR_CONST(0xf004) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_B_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_N_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_SDP_E_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_1_0_RD_WEIGHT_CDMA_DAT_SHIFT) + + +// Register NVDLA_CVIF_CFG_RD_WEIGHT_2_0 +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0 _MK_ADDR_CONST(0xf008) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_CDMA_WT_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RBK_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_1_SHIFT) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_RD_WEIGHT_2_0_RD_WEIGHT_RSV_0_SHIFT) + + +// Register NVDLA_CVIF_CFG_WR_WEIGHT_0_0 +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0 _MK_ADDR_CONST(0xf00c) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_BDMA_SHIFT) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_SDP_SHIFT) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_PDP_SHIFT) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_0_0_WR_WEIGHT_CDP_SHIFT) + + +// Register NVDLA_CVIF_CFG_WR_WEIGHT_1_0 +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0 _MK_ADDR_CONST(0xf010) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RBK_SHIFT) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_2_SHIFT) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT _MK_SHIFT_CONST(16) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_1_SHIFT) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT _MK_SHIFT_CONST(24) +#define NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_WR_WEIGHT_1_0_WR_WEIGHT_RSV_0_SHIFT) + + +// Register NVDLA_CVIF_CFG_OUTSTANDING_CNT_0 +#define NVDLA_CVIF_CFG_OUTSTANDING_CNT_0 _MK_ADDR_CONST(0xf014) +#define NVDLA_CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT _MK_SHIFT_CONST(0) +#define NVDLA_CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_OUTSTANDING_CNT_0_RD_OS_CNT_SHIFT) +#define NVDLA_CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_FIELD _MK_FIELD_CONST(0xff, NVDLA_CVIF_CFG_OUTSTANDING_CNT_0_WR_OS_CNT_SHIFT) + + +// Register NVDLA_CVIF_STATUS_0 +#define NVDLA_CVIF_STATUS_0 _MK_ADDR_CONST(0xf018) +#define NVDLA_CVIF_STATUS_0_IDLE_SHIFT _MK_SHIFT_CONST(8) +#define NVDLA_CVIF_STATUS_0_IDLE_FIELD _MK_FIELD_CONST(0x1, NVDLA_CVIF_STATUS_0_IDLE_SHIFT) +#define NVDLA_CVIF_STATUS_0_IDLE_NO _MK_ENUM_CONST(0x0) +#define NVDLA_CVIF_STATUS_0_IDLE_YES _MK_ENUM_CONST(0x1) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register BDMA_CFG_SRC_ADDR_LOW_0 +#define BDMA_CFG_SRC_ADDR_LOW_0 _MK_ADDR_CONST(0x10000) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_SHIFT _MK_SHIFT_CONST(5) +#define BDMA_CFG_SRC_ADDR_LOW_0_V32_FIELD _MK_FIELD_CONST(0x7ffffff, BDMA_CFG_SRC_ADDR_LOW_0_V32_SHIFT) + + +// Register BDMA_CFG_SRC_ADDR_HIGH_0 +#define BDMA_CFG_SRC_ADDR_HIGH_0 _MK_ADDR_CONST(0x10004) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_SRC_ADDR_HIGH_0_V8_FIELD _MK_FIELD_CONST(0xffffffff, BDMA_CFG_SRC_ADDR_HIGH_0_V8_SHIFT) + + +// Register BDMA_CFG_DST_ADDR_LOW_0 +#define BDMA_CFG_DST_ADDR_LOW_0 _MK_ADDR_CONST(0x10008) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_SHIFT _MK_SHIFT_CONST(5) +#define BDMA_CFG_DST_ADDR_LOW_0_V32_FIELD _MK_FIELD_CONST(0x7ffffff, BDMA_CFG_DST_ADDR_LOW_0_V32_SHIFT) + + +// Register BDMA_CFG_DST_ADDR_HIGH_0 +#define BDMA_CFG_DST_ADDR_HIGH_0 _MK_ADDR_CONST(0x1000c) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_DST_ADDR_HIGH_0_V8_FIELD _MK_FIELD_CONST(0xffffffff, BDMA_CFG_DST_ADDR_HIGH_0_V8_SHIFT) + + +// Register BDMA_CFG_LINE_0 +#define BDMA_CFG_LINE_0 _MK_ADDR_CONST(0x10010) +#define BDMA_CFG_LINE_0_SIZE_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_LINE_0_SIZE_FIELD _MK_FIELD_CONST(0x1fff, BDMA_CFG_LINE_0_SIZE_SHIFT) + + +// Register BDMA_CFG_CMD_0 +#define BDMA_CFG_CMD_0 _MK_ADDR_CONST(0x10014) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, BDMA_CFG_CMD_0_SRC_RAM_TYPE_SHIFT) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_CVSRAM _MK_ENUM_CONST(0x0) +#define BDMA_CFG_CMD_0_SRC_RAM_TYPE_MC _MK_ENUM_CONST(0x1) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_SHIFT _MK_SHIFT_CONST(1) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, BDMA_CFG_CMD_0_DST_RAM_TYPE_SHIFT) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_CVSRAM _MK_ENUM_CONST(0x0) +#define BDMA_CFG_CMD_0_DST_RAM_TYPE_MC _MK_ENUM_CONST(0x1) + + +// Register BDMA_CFG_LINE_REPEAT_0 +#define BDMA_CFG_LINE_REPEAT_0 _MK_ADDR_CONST(0x10018) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_LINE_REPEAT_0_NUMBER_FIELD _MK_FIELD_CONST(0xffffff, BDMA_CFG_LINE_REPEAT_0_NUMBER_SHIFT) + + +// Register BDMA_CFG_SRC_LINE_0 +#define BDMA_CFG_SRC_LINE_0 _MK_ADDR_CONST(0x1001c) +#define BDMA_CFG_SRC_LINE_0_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define BDMA_CFG_SRC_LINE_0_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, BDMA_CFG_SRC_LINE_0_STRIDE_SHIFT) + + +// Register BDMA_CFG_DST_LINE_0 +#define BDMA_CFG_DST_LINE_0 _MK_ADDR_CONST(0x10020) +#define BDMA_CFG_DST_LINE_0_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define BDMA_CFG_DST_LINE_0_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, BDMA_CFG_DST_LINE_0_STRIDE_SHIFT) + + +// Register BDMA_CFG_SURF_REPEAT_0 +#define BDMA_CFG_SURF_REPEAT_0 _MK_ADDR_CONST(0x10024) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_SURF_REPEAT_0_NUMBER_FIELD _MK_FIELD_CONST(0xffffff, BDMA_CFG_SURF_REPEAT_0_NUMBER_SHIFT) + + +// Register BDMA_CFG_SRC_SURF_0 +#define BDMA_CFG_SRC_SURF_0 _MK_ADDR_CONST(0x10028) +#define BDMA_CFG_SRC_SURF_0_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define BDMA_CFG_SRC_SURF_0_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, BDMA_CFG_SRC_SURF_0_STRIDE_SHIFT) + + +// Register BDMA_CFG_DST_SURF_0 +#define BDMA_CFG_DST_SURF_0 _MK_ADDR_CONST(0x1002c) +#define BDMA_CFG_DST_SURF_0_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define BDMA_CFG_DST_SURF_0_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, BDMA_CFG_DST_SURF_0_STRIDE_SHIFT) + + +// Register BDMA_CFG_OP_0 +#define BDMA_CFG_OP_0 _MK_ADDR_CONST(0x10030) +#define BDMA_CFG_OP_0_EN_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_OP_0_EN_FIELD _MK_FIELD_CONST(0x1, BDMA_CFG_OP_0_EN_SHIFT) +#define BDMA_CFG_OP_0_EN_DISABLE _MK_ENUM_CONST(0x0) +#define BDMA_CFG_OP_0_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register BDMA_CFG_LAUNCH0_0 +#define BDMA_CFG_LAUNCH0_0 _MK_ADDR_CONST(0x10034) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_FIELD _MK_FIELD_CONST(0x1, BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_SHIFT) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_NO _MK_ENUM_CONST(0x0) +#define BDMA_CFG_LAUNCH0_0_GRP0_LAUNCH_YES _MK_ENUM_CONST(0x1) + + +// Register BDMA_CFG_LAUNCH1_0 +#define BDMA_CFG_LAUNCH1_0 _MK_ADDR_CONST(0x10038) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_FIELD _MK_FIELD_CONST(0x1, BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_SHIFT) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_NO _MK_ENUM_CONST(0x0) +#define BDMA_CFG_LAUNCH1_0_GRP1_LAUNCH_YES _MK_ENUM_CONST(0x1) + + +// Register BDMA_CFG_STATUS_0 +#define BDMA_CFG_STATUS_0 _MK_ADDR_CONST(0x1003c) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_FIELD _MK_FIELD_CONST(0x1, BDMA_CFG_STATUS_0_STALL_COUNT_EN_SHIFT) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_NO _MK_ENUM_CONST(0x0) +#define BDMA_CFG_STATUS_0_STALL_COUNT_EN_YES _MK_ENUM_CONST(0x1) + + +// Register BDMA_STATUS_0 +#define BDMA_STATUS_0 _MK_ADDR_CONST(0x10040) +#define BDMA_STATUS_0_FREE_SLOT_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_STATUS_0_FREE_SLOT_FIELD _MK_FIELD_CONST(0xff, BDMA_STATUS_0_FREE_SLOT_SHIFT) +#define BDMA_STATUS_0_IDLE_SHIFT _MK_SHIFT_CONST(8) +#define BDMA_STATUS_0_IDLE_FIELD _MK_FIELD_CONST(0x1, BDMA_STATUS_0_IDLE_SHIFT) +#define BDMA_STATUS_0_IDLE_NO _MK_ENUM_CONST(0x0) +#define BDMA_STATUS_0_IDLE_YES _MK_ENUM_CONST(0x1) +#define BDMA_STATUS_0_GRP0_BUSY_SHIFT _MK_SHIFT_CONST(9) +#define BDMA_STATUS_0_GRP0_BUSY_FIELD _MK_FIELD_CONST(0x1, BDMA_STATUS_0_GRP0_BUSY_SHIFT) +#define BDMA_STATUS_0_GRP0_BUSY_NO _MK_ENUM_CONST(0x0) +#define BDMA_STATUS_0_GRP0_BUSY_YES _MK_ENUM_CONST(0x1) +#define BDMA_STATUS_0_GRP1_BUSY_SHIFT _MK_SHIFT_CONST(10) +#define BDMA_STATUS_0_GRP1_BUSY_FIELD _MK_FIELD_CONST(0x1, BDMA_STATUS_0_GRP1_BUSY_SHIFT) +#define BDMA_STATUS_0_GRP1_BUSY_NO _MK_ENUM_CONST(0x0) +#define BDMA_STATUS_0_GRP1_BUSY_YES _MK_ENUM_CONST(0x1) + + +// Register BDMA_STATUS_GRP0_READ_STALL_0 +#define BDMA_STATUS_GRP0_READ_STALL_0 _MK_ADDR_CONST(0x10044) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_STATUS_GRP0_READ_STALL_0_COUNT_FIELD _MK_FIELD_CONST(0xffffffff, BDMA_STATUS_GRP0_READ_STALL_0_COUNT_SHIFT) + + +// Register BDMA_STATUS_GRP0_WRITE_STALL_0 +#define BDMA_STATUS_GRP0_WRITE_STALL_0 _MK_ADDR_CONST(0x10048) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_FIELD _MK_FIELD_CONST(0xffffffff, BDMA_STATUS_GRP0_WRITE_STALL_0_COUNT_SHIFT) + + +// Register BDMA_STATUS_GRP1_READ_STALL_0 +#define BDMA_STATUS_GRP1_READ_STALL_0 _MK_ADDR_CONST(0x1004c) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_STATUS_GRP1_READ_STALL_0_COUNT_FIELD _MK_FIELD_CONST(0xffffffff, BDMA_STATUS_GRP1_READ_STALL_0_COUNT_SHIFT) + + +// Register BDMA_STATUS_GRP1_WRITE_STALL_0 +#define BDMA_STATUS_GRP1_WRITE_STALL_0 _MK_ADDR_CONST(0x10050) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_SHIFT _MK_SHIFT_CONST(0) +#define BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_FIELD _MK_FIELD_CONST(0xffffffff, BDMA_STATUS_GRP1_WRITE_STALL_0_COUNT_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + +// Register RBK_S_STATUS_0 +#define RBK_S_STATUS_0 _MK_ADDR_CONST(0x11000) +#define RBK_S_STATUS_0_STATUS_0_SHIFT _MK_SHIFT_CONST(0) +#define RBK_S_STATUS_0_STATUS_0_FIELD _MK_FIELD_CONST(0x3, RBK_S_STATUS_0_STATUS_0_SHIFT) +#define RBK_S_STATUS_0_STATUS_0_IDLE _MK_ENUM_CONST(0x0) +#define RBK_S_STATUS_0_STATUS_0_RUNNING _MK_ENUM_CONST(0x1) +#define RBK_S_STATUS_0_STATUS_0_PENDING _MK_ENUM_CONST(0x2) +#define RBK_S_STATUS_0_STATUS_1_SHIFT _MK_SHIFT_CONST(16) +#define RBK_S_STATUS_0_STATUS_1_FIELD _MK_FIELD_CONST(0x3, RBK_S_STATUS_0_STATUS_1_SHIFT) +#define RBK_S_STATUS_0_STATUS_1_IDLE _MK_ENUM_CONST(0x0) +#define RBK_S_STATUS_0_STATUS_1_RUNNING _MK_ENUM_CONST(0x1) +#define RBK_S_STATUS_0_STATUS_1_PENDING _MK_ENUM_CONST(0x2) + + +// Register RBK_S_POINTER_0 +#define RBK_S_POINTER_0 _MK_ADDR_CONST(0x11004) +#define RBK_S_POINTER_0_PRODUCER_SHIFT _MK_SHIFT_CONST(0) +#define RBK_S_POINTER_0_PRODUCER_FIELD _MK_FIELD_CONST(0x1, RBK_S_POINTER_0_PRODUCER_SHIFT) +#define RBK_S_POINTER_0_PRODUCER_GROUP_0 _MK_ENUM_CONST(0x0) +#define RBK_S_POINTER_0_PRODUCER_GROUP_1 _MK_ENUM_CONST(0x1) +#define RBK_S_POINTER_0_CONSUMER_SHIFT _MK_SHIFT_CONST(16) +#define RBK_S_POINTER_0_CONSUMER_FIELD _MK_FIELD_CONST(0x1, RBK_S_POINTER_0_CONSUMER_SHIFT) +#define RBK_S_POINTER_0_CONSUMER_GROUP_0 _MK_ENUM_CONST(0x0) +#define RBK_S_POINTER_0_CONSUMER_GROUP_1 _MK_ENUM_CONST(0x1) + + +// Register RBK_D_OP_ENABLE_0 +#define RBK_D_OP_ENABLE_0 _MK_ADDR_CONST(0x11008) +#define RBK_D_OP_ENABLE_0_OP_EN_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_OP_ENABLE_0_OP_EN_FIELD _MK_FIELD_CONST(0x1, RBK_D_OP_ENABLE_0_OP_EN_SHIFT) +#define RBK_D_OP_ENABLE_0_OP_EN_DISABLE _MK_ENUM_CONST(0x0) +#define RBK_D_OP_ENABLE_0_OP_EN_ENABLE _MK_ENUM_CONST(0x1) + + +// Register RBK_D_MISC_CFG_0 +#define RBK_D_MISC_CFG_0 _MK_ADDR_CONST(0x1100c) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_FIELD _MK_FIELD_CONST(0x3, RBK_D_MISC_CFG_0_RUBIK_MODE_SHIFT) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_CONTRACT _MK_ENUM_CONST(0x0) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_SPLIT _MK_ENUM_CONST(0x1) +#define RBK_D_MISC_CFG_0_RUBIK_MODE_MERGE _MK_ENUM_CONST(0x2) +#define RBK_D_MISC_CFG_0_IN_PRECISION_SHIFT _MK_SHIFT_CONST(8) +#define RBK_D_MISC_CFG_0_IN_PRECISION_FIELD _MK_FIELD_CONST(0x3, RBK_D_MISC_CFG_0_IN_PRECISION_SHIFT) +#define RBK_D_MISC_CFG_0_IN_PRECISION_INT8 _MK_ENUM_CONST(0x0) +#define RBK_D_MISC_CFG_0_IN_PRECISION_INT16 _MK_ENUM_CONST(0x1) +#define RBK_D_MISC_CFG_0_IN_PRECISION_FP16 _MK_ENUM_CONST(0x2) + + +// Register RBK_D_DAIN_RAM_TYPE_0 +#define RBK_D_DAIN_RAM_TYPE_0 _MK_ADDR_CONST(0x11010) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_SHIFT) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_CVIF _MK_ENUM_CONST(0x0) +#define RBK_D_DAIN_RAM_TYPE_0_DATAIN_RAM_TYPE_MCIF _MK_ENUM_CONST(0x1) + + +// Register RBK_D_DATAIN_SIZE_0_0 +#define RBK_D_DATAIN_SIZE_0_0 _MK_ADDR_CONST(0x11014) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_FIELD _MK_FIELD_CONST(0x1fff, RBK_D_DATAIN_SIZE_0_0_DATAIN_WIDTH_SHIFT) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT _MK_SHIFT_CONST(16) +#define RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_FIELD _MK_FIELD_CONST(0x1fff, RBK_D_DATAIN_SIZE_0_0_DATAIN_HEIGHT_SHIFT) + + +// Register RBK_D_DATAIN_SIZE_1_0 +#define RBK_D_DATAIN_SIZE_1_0 _MK_ADDR_CONST(0x11018) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, RBK_D_DATAIN_SIZE_1_0_DATAIN_CHANNEL_SHIFT) + + +// Register RBK_D_DAIN_ADDR_HIGH_0 +#define RBK_D_DAIN_ADDR_HIGH_0 _MK_ADDR_CONST(0x1101c) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, RBK_D_DAIN_ADDR_HIGH_0_DAIN_ADDR_HIGH_SHIFT) + + +// Register RBK_D_DAIN_ADDR_LOW_0 +#define RBK_D_DAIN_ADDR_LOW_0 _MK_ADDR_CONST(0x11020) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAIN_ADDR_LOW_0_DAIN_ADDR_LOW_SHIFT) + + +// Register RBK_D_DAIN_LINE_STRIDE_0 +#define RBK_D_DAIN_LINE_STRIDE_0 _MK_ADDR_CONST(0x11024) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAIN_LINE_STRIDE_0_DAIN_LINE_STRIDE_SHIFT) + + +// Register RBK_D_DAIN_SURF_STRIDE_0 +#define RBK_D_DAIN_SURF_STRIDE_0 _MK_ADDR_CONST(0x11028) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAIN_SURF_STRIDE_0_DAIN_SURF_STRIDE_SHIFT) + + +// Register RBK_D_DAIN_PLANAR_STRIDE_0 +#define RBK_D_DAIN_PLANAR_STRIDE_0 _MK_ADDR_CONST(0x1102c) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAIN_PLANAR_STRIDE_0_DAIN_PLANAR_STRIDE_SHIFT) + + +// Register RBK_D_DAOUT_RAM_TYPE_0 +#define RBK_D_DAOUT_RAM_TYPE_0 _MK_ADDR_CONST(0x11030) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_FIELD _MK_FIELD_CONST(0x1, RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_SHIFT) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_CVIF _MK_ENUM_CONST(0x0) +#define RBK_D_DAOUT_RAM_TYPE_0_DATAOUT_RAM_TYPE_MCIF _MK_ENUM_CONST(0x1) + + +// Register RBK_D_DATAOUT_SIZE_1_0 +#define RBK_D_DATAOUT_SIZE_1_0 _MK_ADDR_CONST(0x11034) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_FIELD _MK_FIELD_CONST(0x1fff, RBK_D_DATAOUT_SIZE_1_0_DATAOUT_CHANNEL_SHIFT) + + +// Register RBK_D_DAOUT_ADDR_HIGH_0 +#define RBK_D_DAOUT_ADDR_HIGH_0 _MK_ADDR_CONST(0x11038) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_FIELD _MK_FIELD_CONST(0xffffffff, RBK_D_DAOUT_ADDR_HIGH_0_DAOUT_ADDR_HIGH_SHIFT) + + +// Register RBK_D_DAOUT_ADDR_LOW_0 +#define RBK_D_DAOUT_ADDR_LOW_0 _MK_ADDR_CONST(0x1103c) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAOUT_ADDR_LOW_0_DAOUT_ADDR_LOW_SHIFT) + + +// Register RBK_D_DAOUT_LINE_STRIDE_0 +#define RBK_D_DAOUT_LINE_STRIDE_0 _MK_ADDR_CONST(0x11040) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAOUT_LINE_STRIDE_0_DAOUT_LINE_STRIDE_SHIFT) + + +// Register RBK_D_CONTRACT_STRIDE_0_0 +#define RBK_D_CONTRACT_STRIDE_0_0 _MK_ADDR_CONST(0x11044) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_CONTRACT_STRIDE_0_0_CONTRACT_STRIDE_0_SHIFT) + + +// Register RBK_D_CONTRACT_STRIDE_1_0 +#define RBK_D_CONTRACT_STRIDE_1_0 _MK_ADDR_CONST(0x11048) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_CONTRACT_STRIDE_1_0_CONTRACT_STRIDE_1_SHIFT) + + +// Register RBK_D_DAOUT_SURF_STRIDE_0 +#define RBK_D_DAOUT_SURF_STRIDE_0 _MK_ADDR_CONST(0x1104c) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAOUT_SURF_STRIDE_0_DAOUT_SURF_STRIDE_SHIFT) + + +// Register RBK_D_DAOUT_PLANAR_STRIDE_0 +#define RBK_D_DAOUT_PLANAR_STRIDE_0 _MK_ADDR_CONST(0x11050) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_SHIFT _MK_SHIFT_CONST(5) +#define RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_FIELD _MK_FIELD_CONST(0x7ffffff, RBK_D_DAOUT_PLANAR_STRIDE_0_DAOUT_PLANAR_STRIDE_SHIFT) + + +// Register RBK_D_DECONV_STRIDE_0 +#define RBK_D_DECONV_STRIDE_0 _MK_ADDR_CONST(0x11054) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_FIELD _MK_FIELD_CONST(0x1f, RBK_D_DECONV_STRIDE_0_DECONV_X_STRIDE_SHIFT) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_SHIFT _MK_SHIFT_CONST(16) +#define RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_FIELD _MK_FIELD_CONST(0x1f, RBK_D_DECONV_STRIDE_0_DECONV_Y_STRIDE_SHIFT) + + +// Register RBK_D_PERF_ENABLE_0 +#define RBK_D_PERF_ENABLE_0 _MK_ADDR_CONST(0x11058) +#define RBK_D_PERF_ENABLE_0_PERF_EN_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_PERF_ENABLE_0_PERF_EN_FIELD _MK_FIELD_CONST(0x1, RBK_D_PERF_ENABLE_0_PERF_EN_SHIFT) + + +// Register RBK_D_PERF_READ_STALL_0 +#define RBK_D_PERF_READ_STALL_0 _MK_ADDR_CONST(0x1105c) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_FIELD _MK_FIELD_CONST(0xffffffff, RBK_D_PERF_READ_STALL_0_RD_STALL_CNT_SHIFT) + + +// Register RBK_D_PERF_WRITE_STALL_0 +#define RBK_D_PERF_WRITE_STALL_0 _MK_ADDR_CONST(0x11060) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_SHIFT _MK_SHIFT_CONST(0) +#define RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_FIELD _MK_FIELD_CONST(0xffffffff, RBK_D_PERF_WRITE_STALL_0_WR_STALL_CNT_SHIFT) + + + +// To satisfy various compilers and platforms, +// we let users control the types and syntax of certain constants, using macros. +#ifndef _MK_SHIFT_CONST + #define _MK_SHIFT_CONST(_constant_) _constant_ +#endif +#ifndef _MK_MASK_CONST + #define _MK_MASK_CONST(_constant_) _constant_ +#endif +#ifndef _MK_ENUM_CONST + #define _MK_ENUM_CONST(_constant_) (_constant_ ## UL) +#endif +#ifndef _MK_ADDR_CONST + #define _MK_ADDR_CONST(_constant_) _constant_ +#endif +#ifndef _MK_FIELD_CONST + #define _MK_FIELD_CONST(_mask_, _shift_) (_MK_MASK_CONST(_mask_) << _MK_SHIFT_CONST(_shift_)) +#endif + + + +// +// ADDRESS SPACES +// + +#define BASE_ADDRESS_NVDLA_CFGROM 0x0 +#define BASE_ADDRESS_NVDLA_GLB 0x1000 +#define BASE_ADDRESS_NVDLA_MCIF 0x2000 +#define BASE_ADDRESS_NVDLA_CDMA 0x3000 +#define BASE_ADDRESS_NVDLA_CSC 0x4000 +#define BASE_ADDRESS_NVDLA_CMAC_A 0x5000 +#define BASE_ADDRESS_NVDLA_CMAC_B 0x6000 +#define BASE_ADDRESS_NVDLA_CACC 0x7000 +#define BASE_ADDRESS_NVDLA_SDP_RDMA 0x8000 +#define BASE_ADDRESS_NVDLA_SDP 0x9000 +#define BASE_ADDRESS_NVDLA_PDP_RDMA 0xa000 +#define BASE_ADDRESS_NVDLA_PDP 0xb000 +#define BASE_ADDRESS_NVDLA_CDP_RDMA 0xc000 +#define BASE_ADDRESS_NVDLA_CDP 0xd000 +#define BASE_ADDRESS_NVDLA_GEC 0xe000 +#define BASE_ADDRESS_NVDLA_CVIF 0xf000 +#define BASE_ADDRESS_NVDLA_BDMA 0x10000 +#define BASE_ADDRESS_NVDLA_RBK 0x11000 + +#endif |