nvdla: add NVDLA driver

Additional update from Prashant Gaikwad <pgaikwad@nvidia.com>
Adapted for Linux 5.13 and the BeagleV Starlight board by
<cybergaszcz@gmail.com>

kernel test robot: fix platform_no_drv_owner.cocci warnings
Geert: Use div_u64() in dla_get_time_us()

Signed-off-by: kernel test robot <lkp@intel.com>
Link: https://lore.kernel.org/r/20220119060057.GA1143@7f39e361da8f
Signed-off-by: Geert Uytterhoeven <geert@linux-m68k.org>
Link: https://lore.kernel.org/r/alpine.DEB.2.22.394.2203090905560.780932@ramsan.of.borg
Signed-off-by: Emil Renner Berthing <kernel@esmil.dk>

diff --git a/drivers/Kconfig b/drivers/Kconfig
index 19ee995..1d461be 100644 (file)
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -239,4 +239,6 @@ source "drivers/peci/Kconfig"
 
 source "drivers/hte/Kconfig"
 
+source "drivers/nvdla/Kconfig"
+
 endmenu

diff --git a/drivers/Makefile b/drivers/Makefile
index bdf1c66..d305c51 100644 (file)
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -189,3 +189,4 @@ obj-$(CONFIG_COUNTER)               += counter/
 obj-$(CONFIG_MOST)             += most/
 obj-$(CONFIG_PECI)             += peci/
 obj-$(CONFIG_HTE)              += hte/
+obj-$(CONFIG_NVDLA)            += nvdla/

diff --git a/drivers/nvdla/Kconfig b/drivers/nvdla/Kconfig
new file mode 100644 (file)
index 0000000..fdbb82b
--- /dev/null
+++ b/drivers/nvdla/Kconfig
@@ -0,0 +1,4 @@
+config NVDLA
+       tristate "The NVIDIA Deep Learning Accelerator"
+       depends on DRM
+       select DRM_GEM_DMA_HELPER

diff --git a/drivers/nvdla/Makefile b/drivers/nvdla/Makefile
new file mode 100644 (file)
index 0000000..4ba437a
--- /dev/null
+++ b/drivers/nvdla/Makefile
@@ -0,0 +1,21 @@
+
+ccflags-y += -I$(srctree)/$(src)
+ccflags-y += -I$(srctree)/$(src)/include
+
+nvdla-y := scheduler.o \
+          engine.o \
+          bdma.o \
+          conv.o \
+          sdp.o \
+          cdp.o \
+          pdp.o \
+          rubik.o \
+          cache.o \
+          common.o \
+          engine_data.o \
+          engine_isr.o \
+          engine_debug.o \
+          nvdla_core_callbacks.o \
+          nvdla_gem.o
+
+obj-$(CONFIG_NVDLA) += nvdla.o

diff --git a/drivers/nvdla/bdma.c b/drivers/nvdla/bdma.c
new file mode 100644 (file)
index 0000000..8822c2c
--- /dev/null
+++ b/drivers/nvdla/bdma.c
@@ -0,0 +1,280 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "dla_engine_internal.h"
+#include "engine_debug.h"
+
+static const uint8_t map_mem[] = {
+       FIELD_ENUM(BDMA_CFG_CMD_0, SRC_RAM_TYPE, MC),
+       FIELD_ENUM(BDMA_CFG_CMD_0, SRC_RAM_TYPE, CVSRAM),
+};
+
+#if STAT_ENABLE
+void
+dla_bdma_stat_data(struct dla_processor *processor,
+                                       struct dla_processor_group *group)
+{
+       uint64_t end_time = 0;
+       struct dla_bdma_stat_desc *bdma_stat;
+
+       bdma_stat = &processor->stat_data_desc->bdma_stat;
+
+       end_time = dla_get_time_us();
+
+       if (group->id == (uint32_t)0) {
+               bdma_stat->read_stall = bdma_reg_read(STATUS_GRP0_READ_STALL);
+               bdma_stat->write_stall = bdma_reg_read(STATUS_GRP0_WRITE_STALL);
+       } else {
+               bdma_stat->read_stall = bdma_reg_read(STATUS_GRP1_READ_STALL);
+               bdma_stat->write_stall = bdma_reg_read(STATUS_GRP1_WRITE_STALL);
+       }
+       bdma_stat->runtime = (uint32_t)(end_time - group->start_time);
+}
+
+void
+dla_bdma_dump_stat(struct dla_processor *processor)
+{
+       struct dla_bdma_stat_desc *bdma_stat;
+
+       bdma_stat = &processor->stat_data_desc->bdma_stat;
+
+       dla_debug_bdma_stats(bdma_stat);
+}
+#endif /* STAT_ENABLE */
+
+void
+dla_bdma_set_producer(int32_t group_id, int32_t rdma_group_id)
+{
+       /*
+        * There is no producer bit for BDMA operation,
+        * interrupt pointer decides which outstanding request
+        * to use for this BDMA operation
+        */
+}
+
+int
+dla_bdma_enable(struct dla_processor_group *group)
+{
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter: %s\n", __func__);
+
+       if (group->surface_desc->bdma_surface.num_transfers == (uint16_t)0) {
+               group->events |= ((uint8_t)1 << DLA_EVENT_OP_COMPLETED);
+               goto exit;
+       }
+
+       if (engine->stat_enable == (uint32_t)1) {
+               bdma_reg_write(CFG_STATUS, FIELD_ENUM(BDMA_CFG_STATUS_0,
+                                                       STALL_COUNT_EN, YES));
+               group->start_time = dla_get_time_us();
+       }
+
+       /*
+        * Launch BDMA transfer
+        */
+       if (group->id == 0)
+               bdma_reg_write(CFG_LAUNCH0, FIELD_ENUM(BDMA_CFG_LAUNCH0_0,
+                                                       GRP0_LAUNCH, YES));
+       else
+               bdma_reg_write(CFG_LAUNCH1, FIELD_ENUM(BDMA_CFG_LAUNCH1_0,
+                                                       GRP1_LAUNCH, YES));
+
+exit:
+       dla_debug("Exit: %s\n", __func__);
+       return 0;
+}
+
+void
+dla_bdma_rdma_check(struct dla_processor_group *group)
+{
+       group->is_rdma_needed = 0;
+}
+
+/*
+ * Program BDMA slot for transfer
+ */
+static int32_t
+processor_bdma_program_slot(struct dla_bdma_surface_desc *bdma_surface,
+                               struct dla_bdma_transfer_desc *transfer)
+{
+       int32_t ret = 0;
+       uint64_t source_addr = 0;
+       uint64_t destination_addr = 0;
+       uint32_t high, low, reg;
+       uint8_t  bdma_free_slots = 0;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter: %s\n", __func__);
+
+       /* make sure there're enough free slots */
+       if (bdma_free_slots <= 0) {
+               do {
+                       reg = bdma_reg_read(STATUS);
+                       reg = (reg & MASK(BDMA_STATUS_0, FREE_SLOT)) >>
+                                       SHIFT(BDMA_STATUS_0, FREE_SLOT);
+               } while (reg == 0);
+               bdma_free_slots = (uint8_t)reg;
+       }
+
+       dla_get_dma_address(engine->driver_context, engine->task->task_data,
+                                               transfer->source_address,
+                                               (void *)&source_addr,
+                                               DESTINATION_DMA);
+       dla_get_dma_address(engine->driver_context, engine->task->task_data,
+                                               transfer->destination_address,
+                                               (void *)&destination_addr,
+                                               DESTINATION_DMA);
+
+       ASSERT_GOTO((transfer->line_repeat <= 8192),
+                               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO((transfer->surface_repeat <= 8192),
+                               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO((transfer->line_size % 32) == 0,
+                               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO(transfer->source_line >= transfer->line_size,
+                               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO(transfer->destination_line >= transfer->line_size,
+                               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO(transfer->source_surface >=
+                       (transfer->source_line * transfer->line_repeat),
+                               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO(transfer->destination_surface >=
+                       (transfer->destination_line * transfer->line_repeat),
+                               ret, ERR(INVALID_INPUT), exit);
+
+       /* config registers */
+       high = HIGH32BITS(source_addr);
+       low = LOW32BITS(source_addr);
+       bdma_reg_write(CFG_SRC_ADDR_LOW, low);
+       bdma_reg_write(CFG_SRC_ADDR_HIGH, high);
+       high = HIGH32BITS(destination_addr);
+       low = LOW32BITS(destination_addr);
+       bdma_reg_write(CFG_DST_ADDR_LOW, low);
+       bdma_reg_write(CFG_DST_ADDR_HIGH, high);
+       bdma_reg_write(CFG_LINE, (transfer->line_size >> 5) - 1);
+       reg = (map_mem[bdma_surface->source_type] <<
+                               SHIFT(BDMA_CFG_CMD_0, SRC_RAM_TYPE)) |
+               (map_mem[bdma_surface->destination_type] <<
+                               SHIFT(BDMA_CFG_CMD_0, DST_RAM_TYPE));
+       bdma_reg_write(CFG_CMD, reg);
+       bdma_reg_write(CFG_LINE_REPEAT, transfer->line_repeat - 1);
+       bdma_reg_write(CFG_SRC_LINE, transfer->source_line);
+       bdma_reg_write(CFG_DST_LINE, transfer->destination_line);
+       bdma_reg_write(CFG_SURF_REPEAT, transfer->surface_repeat - 1);
+       bdma_reg_write(CFG_SRC_SURF, transfer->source_surface);
+       bdma_reg_write(CFG_DST_SURF, transfer->destination_surface);
+       bdma_reg_write(CFG_OP, FIELD_ENUM(BDMA_CFG_OP_0, EN, ENABLE));
+
+       dla_debug("Exit: %s\n", __func__);
+
+exit:
+       RETURN(ret);
+}
+
+int
+dla_bdma_is_ready(struct dla_processor *processor,
+                           struct dla_processor_group *group)
+{
+       struct dla_processor_group *next_group;
+
+       next_group = &processor->groups[!group->id];
+
+       /*
+        * If another group is already programmed but not active then
+        * do not program this operation as BDMA does not really
+        * have shadow copies for groups. It will end programming
+        * same group. Wait for another group to get enabled.
+        */
+       if ((processor->group_status & (1 << next_group->id)) &&
+                                               !next_group->active)
+               return 0;
+
+       return 1;
+}
+
+void
+dla_bdma_dump_config(struct dla_processor_group *group)
+{
+       struct dla_bdma_op_desc *bdma_op;
+       struct dla_bdma_surface_desc *bdma_surface;
+
+       bdma_surface = &group->surface_desc->bdma_surface;
+       bdma_op = &group->operation_desc->bdma_op;
+
+       dla_debug_bdma_surface_desc(bdma_surface, group->roi_index);
+       dla_debug_bdma_op_desc(bdma_op, group->roi_index);
+}
+
+int
+dla_bdma_program(struct dla_processor_group *group)
+{
+       int32_t i;
+       int32_t ret = 0;
+       struct dla_bdma_surface_desc *bdma_surface;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter: %s\n", __func__);
+
+       if (!engine->config_data->bdma_enable) {
+               dla_error("BDMA is not supported for this configuration\n");
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       bdma_surface = &group->surface_desc->bdma_surface;
+
+       dla_debug("Num of transfers %u\n", bdma_surface->num_transfers);
+       if (bdma_surface->num_transfers == (uint16_t)0)
+               goto exit;
+
+       if (bdma_surface->num_transfers > NUM_MAX_BDMA_OPS) {
+               dla_error("Invalid number of transfers\n");
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       for (i = 0; i < bdma_surface->num_transfers; i++) {
+               ret = processor_bdma_program_slot(bdma_surface,
+                                       &bdma_surface->transfers[i]);
+               if (ret)
+                       goto exit;
+       }
+
+       dla_enable_intr(MASK(GLB_S_INTR_MASK_0, BDMA_DONE_MASK1) |
+                       MASK(GLB_S_INTR_MASK_0, BDMA_DONE_MASK0));
+
+exit:
+       dla_debug("Exit: %s\n", __func__);
+       RETURN(ret);
+}

diff --git a/drivers/nvdla/cache.c b/drivers/nvdla/cache.c
new file mode 100644 (file)
index 0000000..c9ba143
--- /dev/null
+++ b/drivers/nvdla/cache.c
@@ -0,0 +1,253 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_engine.h>
+#include <dla_interface.h>
+
+#include "dla_engine_internal.h"
+
+#define DLA_OP_CACHE_SIZE (DLA_NUM_GROUPS * ((DLA_OP_NUM + 2) * 2))
+
+static struct dla_common_op_desc desc_cache[DLA_OP_NUM][DLA_OP_CACHE_SIZE];
+static int32_t desc_refcount[DLA_OP_NUM][DLA_OP_CACHE_SIZE];
+
+void
+dla_get_refcount(struct dla_common_op_desc *op_desc)
+{
+       int32_t i;
+       struct dla_common_op_desc *desc = NULL;
+
+       if (op_desc == NULL)
+               return;
+
+       if (op_desc->index == -1)
+               return;
+
+       desc = &desc_cache[op_desc->op_type][0];
+
+       for (i = 0; i < DLA_OP_CACHE_SIZE; i++, desc++) {
+               if (desc->index == op_desc->index &&
+                               desc->roi_index == op_desc->roi_index) {
+                       desc_refcount[op_desc->op_type][i]++;
+                       return;
+               }
+       }
+}
+
+struct dla_common_op_desc *
+dla_get_op_desc(struct dla_task *task, int16_t index,
+                       uint8_t op_type, uint8_t roi_index)
+{
+       int32_t i;
+       int32_t ret;
+       uint64_t op_base;
+       uint64_t dep_graph_addr;
+       struct dla_common_op_desc *desc = NULL;
+       struct dla_engine *engine = dla_get_engine();
+
+       if (index == -1) {
+               dla_debug("no desc get due to index==-1\n");
+               goto exit;
+       }
+
+       dep_graph_addr = (sizeof(struct dla_common_op_desc) *
+                               engine->network->num_operations * roi_index);
+
+       desc = &desc_cache[op_type][0];
+
+       for (i = 0; i < DLA_OP_CACHE_SIZE; i++, desc++) {
+               if (desc->index == index && desc->roi_index == roi_index) {
+                       if (desc->op_type != op_type) {
+                               dla_error("op_cache[op=%u] contains incorrect "
+                                               "entry of op[%u]\n", op_type,
+                                               desc->op_type);
+                               continue;
+                       }
+                       desc_refcount[op_type][i]++;
+                       goto exit;
+               }
+       }
+
+       desc = &desc_cache[op_type][0];
+
+       for (i = 0; i < DLA_OP_CACHE_SIZE; i++, desc++) {
+               if (desc->index == -1) {
+                       op_base = dep_graph_addr +
+                                       (sizeof(struct dla_common_op_desc) *
+                                       (uint64_t)index);
+                       ret = dla_data_read(engine->driver_context,
+                                       task->task_data,
+                                       task->dependency_graph_addr,
+                                       (void *)(desc),
+                                       sizeof(struct dla_common_op_desc),
+                                       op_base);
+                       if (ret) {
+                               desc = NULL;
+                               goto exit;
+                       }
+
+                       if (op_type != desc->op_type) {
+                               /*
+                                * op_type of entry read from DRAM should not
+                                * mismatch with given op_type. If they
+                                * mismatches, then wrong entry is fetched, so
+                                * report this issue by throwing error.
+                                */
+                               dla_error("Fetched [op_type=%u] from DRAM doesn't "
+                                       "match with op_type[%u]\n",
+                                       desc->op_type,
+                                       op_type);
+                               desc->op_type = op_type;
+                               desc->index = -1;
+                               desc->roi_index = -1;
+                               desc = NULL;
+                               goto exit;
+                       }
+
+                       desc->index = index;
+                       desc->roi_index = roi_index;
+
+                       /**
+                        * Refcount must be 0 if we are reading it first time
+                        * from DRAM
+                        */
+                       assert(desc_refcount[op_type][i] == 0);
+
+                       desc_refcount[op_type][i]++;
+                       goto exit;
+               }
+       }
+
+exit:
+       return desc;
+}
+
+static void
+dla_free_op_desc(struct dla_common_op_desc *op_desc)
+{
+       uint64_t op_base;
+       uint64_t dep_graph_addr;
+       struct dla_task *task;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter: %s op desc index %u ROI %d\n", __func__,
+                               op_desc->index, op_desc->roi_index);
+
+       task = engine->task;
+       dep_graph_addr = (sizeof(struct dla_common_op_desc) *
+                               engine->network->num_operations *
+                               op_desc->roi_index);
+
+       if (op_desc->index == -1)
+               goto exit;
+
+       if (op_desc == NULL)
+               goto exit;
+
+       /**
+        * TODO: keeping the depth value hardcoded as 0 for now,
+        * need to replace it once corresponding implementation is done.
+        */
+       op_base = (dep_graph_addr +
+                       (sizeof(struct dla_common_op_desc) *
+                       (uint64_t)op_desc->index));
+
+       /**
+        * Flush descriptor to DRAM
+        */
+       dla_data_write(engine->driver_context,
+                       task->task_data,
+                       (void *)op_desc,
+                       task->dependency_graph_addr,
+                       sizeof(struct dla_common_op_desc),
+                       op_base);
+
+       /**
+        * Release it
+        */
+       op_desc->index = -1;
+       op_desc->roi_index = -1;
+exit:
+       dla_debug("Exit: %s\n", __func__);
+}
+
+void
+dla_put_op_desc(struct dla_common_op_desc *op_desc)
+{
+       int32_t i;
+       struct dla_common_op_desc *desc;
+
+       if (op_desc == NULL)
+               return;
+
+       if (op_desc->index == -1)
+               return;
+
+       desc = &desc_cache[op_desc->op_type][0];
+
+       for (i = 0; i < DLA_OP_CACHE_SIZE; i++, desc++) {
+               if (desc->index == op_desc->index &&
+                               desc->roi_index == op_desc->roi_index) {
+                       /**
+                        * Refcount can't be 0 when we are trying to free it
+                        */
+                       assert(desc_refcount[op_desc->op_type][i] > 0);
+
+                       desc_refcount[op_desc->op_type][i]--;
+
+                       /**
+                        * Free desc if refcount is 0
+                        */
+                       if (desc_refcount[op_desc->op_type][i] == 0)
+                               dla_free_op_desc(op_desc);
+
+                       return;
+               }
+       }
+}
+
+void
+dla_init_op_cache(struct dla_engine *engine)
+{
+       int32_t i, j;
+       struct dla_common_op_desc *desc = &desc_cache[0][0];
+
+       dla_memset((uint8_t *)&desc_cache[0][0], 0, sizeof(desc_cache));
+       dla_memset((uint8_t *)&desc_refcount[0][0], 0, sizeof(desc_refcount));
+
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               for (j = 0; j < DLA_OP_CACHE_SIZE; j++) {
+                       desc->index = -1;
+                       desc->roi_index = -1;
+                       desc->op_type = (uint8_t)i;
+                       desc++;
+               }
+       }
+}

diff --git a/drivers/nvdla/cdp.c b/drivers/nvdla/cdp.c
new file mode 100644 (file)
index 0000000..e839676
--- /dev/null
+++ b/drivers/nvdla/cdp.c
@@ -0,0 +1,384 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "common.h"
+#include "dla_engine_internal.h"
+#include "engine_debug.h"
+
+static const uint8_t map_ram[] = {
+       FIELD_ENUM(CDP_RDMA_D_SRC_DMA_CFG_0, SRC_RAM_TYPE, MC),
+       FIELD_ENUM(CDP_RDMA_D_SRC_DMA_CFG_0, SRC_RAM_TYPE, CV),
+};
+
+static const uint8_t map_precision[] = {
+       FIELD_ENUM(CDP_RDMA_D_DATA_FORMAT_0, INPUT_DATA, INT8),
+       FIELD_ENUM(CDP_RDMA_D_DATA_FORMAT_0, INPUT_DATA, INT16),
+       FIELD_ENUM(CDP_RDMA_D_DATA_FORMAT_0, INPUT_DATA, FP16),
+};
+
+static const uint8_t map_perf_dma[] = {
+       FIELD_ENUM(CDP_D_PERF_ENABLE_0, DMA_EN, DISABLE),
+       FIELD_ENUM(CDP_D_PERF_ENABLE_0, DMA_EN, ENABLE),
+};
+
+static const uint8_t map_perf_lut[] = {
+       FIELD_ENUM(CDP_D_PERF_ENABLE_0, LUT_EN, DISABLE),
+       FIELD_ENUM(CDP_D_PERF_ENABLE_0, LUT_EN, ENABLE),
+};
+
+#if STAT_ENABLE
+void
+dla_cdp_stat_data(struct dla_processor *processor,
+                                       struct dla_processor_group *group)
+{
+       uint64_t end_time = 0;
+       struct dla_cdp_stat_desc *cdp_stat;
+
+       cdp_stat = &processor->stat_data_desc->cdp_stat;
+
+       end_time = dla_get_time_us();
+
+       cdp_stat->write_stall = cdp_reg_read(D_PERF_WRITE_STALL);
+       cdp_stat->lut_uflow = cdp_reg_read(D_PERF_LUT_UFLOW);
+       cdp_stat->lut_oflow = cdp_reg_read(D_PERF_LUT_OFLOW);
+       cdp_stat->lut_hybrid = cdp_reg_read(D_PERF_LUT_HYBRID);
+       cdp_stat->lut_le_hit = cdp_reg_read(D_PERF_LUT_LE_HIT);
+       cdp_stat->lut_lo_hit = cdp_reg_read(D_PERF_LUT_LO_HIT);
+       cdp_stat->runtime = (uint32_t)(end_time - group->start_time);
+}
+
+void
+dla_cdp_dump_stat(struct dla_processor *processor)
+{
+       struct dla_cdp_stat_desc *cdp_stat;
+
+       cdp_stat = &processor->stat_data_desc->cdp_stat;
+
+       dla_debug_cdp_stats(cdp_stat);
+}
+#endif /* STAT_ENABLE */
+
+static uint32_t
+map_local_size(uint8_t local_size)
+{
+       return ((local_size-1)/2)-1;
+}
+
+void
+dla_cdp_set_producer(int32_t group_id, int32_t rdma_group_id)
+{
+       uint32_t reg;
+
+       /**
+        * set producer pointer for all sub-modules
+        */
+       reg = group_id << SHIFT(CDP_S_POINTER_0, PRODUCER);
+       cdp_reg_write(S_POINTER, reg);
+       reg = group_id << SHIFT(CDP_RDMA_S_POINTER_0, PRODUCER);
+       cdp_rdma_reg_write(S_POINTER, reg);
+}
+
+int
+dla_cdp_enable(struct dla_processor_group *group)
+{
+       uint32_t reg;
+       uint8_t perf_reg;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter: %s\n", __func__);
+
+       if (engine->stat_enable == (uint32_t)1) {
+               perf_reg = (map_perf_dma[1] <<
+                               SHIFT(CDP_D_PERF_ENABLE_0, DMA_EN)) |
+                       (map_perf_lut[1] <<
+                               SHIFT(CDP_D_PERF_ENABLE_0, LUT_EN));
+
+               cdp_reg_write(D_PERF_ENABLE, perf_reg);
+               group->start_time = dla_get_time_us();
+       }
+
+       /**
+        * enable all sub-modules
+        */
+       reg = FIELD_ENUM(CDP_RDMA_D_OP_ENABLE_0, OP_EN, ENABLE);
+       cdp_rdma_reg_write(D_OP_ENABLE, reg);
+       reg = FIELD_ENUM(CDP_D_OP_ENABLE_0, OP_EN, ENABLE);
+       cdp_reg_write(D_OP_ENABLE, reg);
+
+       dla_debug("Exit: %s\n", __func__);
+
+       RETURN(0);
+}
+
+void
+dla_cdp_rdma_check(struct dla_processor_group *group)
+{
+       group->is_rdma_needed = 1;
+}
+
+static int32_t
+processor_cdp_program(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       uint32_t reg, high, low;
+       uint64_t input_address = 0;
+       uint64_t output_address = 0;
+       struct dla_lut_param lut;
+       struct dla_engine *engine = dla_get_engine();
+       struct dla_cdp_op_desc *cdp_op;
+       struct dla_cdp_surface_desc *cdp_surface;
+
+       dla_debug("Enter: %s\n", __func__);
+
+       cdp_op = &group->operation_desc->cdp_op;
+       cdp_surface = &group->surface_desc->cdp_surface;
+
+       /* Argument check */
+       if (cdp_surface->src_data.type == DLA_MEM_HW) {
+               dla_error("Invalid source memory type\n");
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+       if (cdp_surface->dst_data.type == DLA_MEM_HW) {
+               dla_error("Invalid destination memory type\n");
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if (cdp_op->in_precision != cdp_op->out_precision) {
+               dla_error("CDP does not support precision conversion\n");
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       /* get the addresses from task descriptor */
+       ret = dla_read_input_address(&cdp_surface->src_data,
+                                               &input_address,
+                                               group->op_desc->index,
+                                               group->roi_index,
+                                               1);
+       if (ret)
+               goto exit;
+
+       dla_get_dma_cube_address(engine->driver_context,
+                               engine->task->task_data,
+                               cdp_surface->dst_data.address,
+                               cdp_surface->dst_data.offset,
+                               (void *)&output_address,
+                               DESTINATION_DMA);
+       if (cdp_op->lut_index >= 0) {
+               group->lut_index = cdp_op->lut_index;
+               dla_read_lut(engine, cdp_op->lut_index, (void *)&lut);
+               dla_debug_lut_params(&lut);
+       }
+
+       /* config CDP RDMA registers */
+       reg = ((cdp_surface->src_data.width - 1)
+               << SHIFT(CDP_RDMA_D_DATA_CUBE_WIDTH_0, WIDTH));
+       cdp_rdma_reg_write(D_DATA_CUBE_WIDTH, reg);
+
+       reg = ((cdp_surface->src_data.height - 1)
+               << SHIFT(CDP_RDMA_D_DATA_CUBE_HEIGHT_0, HEIGHT));
+       cdp_rdma_reg_write(D_DATA_CUBE_HEIGHT, reg);
+
+       reg = ((cdp_surface->src_data.channel - 1)
+               << SHIFT(CDP_RDMA_D_DATA_CUBE_CHANNEL_0, CHANNEL));
+       cdp_rdma_reg_write(D_DATA_CUBE_CHANNEL, reg);
+
+       high = HIGH32BITS(input_address);
+       low = LOW32BITS(input_address);
+       cdp_rdma_reg_write(D_SRC_BASE_ADDR_LOW, low);
+       cdp_rdma_reg_write(D_SRC_BASE_ADDR_HIGH, high);
+
+       cdp_rdma_reg_write(D_SRC_LINE_STRIDE,
+                       cdp_surface->src_data.line_stride);
+       cdp_rdma_reg_write(D_SRC_SURFACE_STRIDE,
+                       cdp_surface->src_data.surf_stride);
+
+       reg = (map_ram[cdp_surface->src_data.type]
+               << SHIFT(CDP_RDMA_D_SRC_DMA_CFG_0, SRC_RAM_TYPE));
+       cdp_rdma_reg_write(D_SRC_DMA_CFG, reg);
+
+       reg = (map_precision[cdp_op->in_precision]
+               << SHIFT(CDP_RDMA_D_DATA_FORMAT_0, INPUT_DATA));
+       cdp_rdma_reg_write(D_DATA_FORMAT, reg);
+
+       /* config CDP */
+       if (cdp_op->lut_index >= 0)
+               update_lut(CDP_S_LUT_ACCESS_CFG_0, &lut, cdp_op->in_precision);
+
+       high = HIGH32BITS(output_address);
+       low = LOW32BITS(output_address);
+       cdp_reg_write(D_DST_BASE_ADDR_LOW, low);
+       cdp_reg_write(D_DST_BASE_ADDR_HIGH, high);
+
+       cdp_reg_write(D_DST_LINE_STRIDE, cdp_surface->dst_data.line_stride);
+       cdp_reg_write(D_DST_SURFACE_STRIDE, cdp_surface->dst_data.surf_stride);
+
+       reg = (map_ram[cdp_surface->dst_data.type]
+               << SHIFT(CDP_D_DST_DMA_CFG_0, DST_RAM_TYPE));
+       cdp_reg_write(D_DST_DMA_CFG, reg);
+
+       reg = (map_precision[cdp_op->in_precision]
+               << SHIFT(CDP_D_DATA_FORMAT_0, INPUT_DATA_TYPE));
+       cdp_reg_write(D_DATA_FORMAT, reg);
+
+       reg = (map_local_size(cdp_op->local_size)
+               << SHIFT(CDP_D_LRN_CFG_0, NORMALZ_LEN));
+       cdp_reg_write(D_LRN_CFG, reg);
+
+       reg = (cdp_op->in_cvt.offset
+               << SHIFT(CDP_D_DATIN_OFFSET_0, DATIN_OFFSET));
+       cdp_reg_write(D_DATIN_OFFSET, reg);
+
+       reg = (cdp_op->in_cvt.scale
+               << SHIFT(CDP_D_DATIN_SCALE_0, DATIN_SCALE));
+       cdp_reg_write(D_DATIN_SCALE, reg);
+
+       reg = (cdp_op->in_cvt.truncate
+               << SHIFT(CDP_D_DATIN_SHIFTER_0, DATIN_SHIFTER));
+       cdp_reg_write(D_DATIN_SHIFTER, reg);
+
+       reg = (cdp_op->out_cvt.offset
+               << SHIFT(CDP_D_DATOUT_OFFSET_0, DATOUT_OFFSET));
+       cdp_reg_write(D_DATOUT_OFFSET, reg);
+
+       reg = (cdp_op->out_cvt.scale
+               << SHIFT(CDP_D_DATOUT_SCALE_0, DATOUT_SCALE));
+       cdp_reg_write(D_DATOUT_SCALE, reg);
+
+       reg = (cdp_op->out_cvt.truncate
+               << SHIFT(CDP_D_DATOUT_SHIFTER_0, DATOUT_SHIFTER));
+       cdp_reg_write(D_DATOUT_SHIFTER, reg);
+
+       reg = ((cdp_op->bypass_sqsum ?
+               FIELD_ENUM(CDP_D_FUNC_BYPASS_0, SQSUM_BYPASS, ENABLE) :
+               FIELD_ENUM(CDP_D_FUNC_BYPASS_0, SQSUM_BYPASS, DISABLE)) <<
+               SHIFT(CDP_D_FUNC_BYPASS_0, SQSUM_BYPASS)) |
+               ((cdp_op->bypass_out_mul ?
+               FIELD_ENUM(CDP_D_FUNC_BYPASS_0, MUL_BYPASS, ENABLE) :
+               FIELD_ENUM(CDP_D_FUNC_BYPASS_0, MUL_BYPASS, DISABLE)) <<
+               SHIFT(CDP_D_FUNC_BYPASS_0, MUL_BYPASS));
+       cdp_reg_write(D_FUNC_BYPASS, reg);
+
+exit:
+       dla_debug("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+int
+dla_cdp_is_ready(struct dla_processor *processor,
+                struct dla_processor_group *group)
+{
+       struct dla_processor_group *next_group;
+       struct dla_cdp_op_desc *cdp_op;
+
+       cdp_op = &group->operation_desc->cdp_op;
+       next_group = &processor->groups[!group->id];
+
+       /**
+        * Single LUT is shared between two CDP groups, need to make
+        * sure that usage does not conflict. Also, LUT write
+        * access is locked when CDP sub-engine is active, so delay
+        * writing LUT when another group is active.
+        */
+
+       /**
+        * if no LUT required for current group then it can be programmed
+        * without further checks
+        */
+       if (cdp_op->lut_index == -1)
+               return 1;
+
+       /**
+        * if same LUT is used for both groups then it can be programmed
+        * without more checks. Even if another group is active and LUT
+        * is locked, it would have been programmed by another group.
+        */
+       if (next_group->lut_index == cdp_op->lut_index)
+               return 1;
+
+       /**
+        * if LUT index of another group is not -1 means some LUT is programmed,
+        * then do not program current LUT as we already know current LUT is not
+        * -1 and neither same as another group.
+        */
+       if (next_group->lut_index != -1)
+               return 0;
+
+       /**
+        * if current group needs LUT different than another group and that
+        * group is not active then program it.
+        */
+       if (!next_group->active)
+               return 1;
+
+       /**
+        * if control is here it means current group is using LUT different than
+        * another group and that group is active. Wait for another group to
+        * become idle.
+        */
+
+       return 0;
+}
+
+void
+dla_cdp_dump_config(struct dla_processor_group *group)
+{
+       struct dla_cdp_op_desc *cdp_op;
+       struct dla_cdp_surface_desc *cdp_surface;
+
+       cdp_surface = &group->surface_desc->cdp_surface;
+       cdp_op = &group->operation_desc->cdp_op;
+
+       dla_debug_cdp_surface_desc(cdp_surface, group->roi_index);
+       dla_debug_cdp_op_desc(cdp_op, group->roi_index);
+}
+
+int
+dla_cdp_program(struct dla_processor_group *group)
+{
+       int32_t ret;
+
+       dla_debug("Enter: %s", __func__);
+       dla_enable_intr(MASK(GLB_S_INTR_MASK_0, CDP_DONE_MASK1) |
+                       MASK(GLB_S_INTR_MASK_0, CDP_DONE_MASK0));
+
+       ret = processor_cdp_program(group);
+       if (ret)
+               goto exit;
+
+exit:
+       dla_debug("Exit: %s", __func__);
+       RETURN(ret);
+}

diff --git a/drivers/nvdla/common.c b/drivers/nvdla/common.c
new file mode 100644 (file)
index 0000000..c36c6ff
--- /dev/null
+++ b/drivers/nvdla/common.c
@@ -0,0 +1,324 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "common.h"
+#include "dla_engine_internal.h"
+
+static const uint8_t map_lut_method[] = {
+       FIELD_ENUM(CDP_S_LUT_CFG_0, LUT_LE_FUNCTION, EXPONENT),
+       FIELD_ENUM(CDP_S_LUT_CFG_0, LUT_LE_FUNCTION, LINEAR)
+};
+static const uint8_t map_lut_out[] = {
+       FIELD_ENUM(CDP_S_LUT_CFG_0, LUT_UFLOW_PRIORITY, LE),
+       FIELD_ENUM(CDP_S_LUT_CFG_0, LUT_UFLOW_PRIORITY, LO)
+};
+
+static const uint16_t access_data_offset[] = {
+       CDP_S_LUT_ACCESS_DATA_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_ACCESS_DATA_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t lut_cfg_offset[] = {
+       CDP_S_LUT_CFG_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_CFG_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t lut_info_offset[] = {
+       CDP_S_LUT_INFO_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_INFO_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t le_start_offset[] = {
+       CDP_S_LUT_LE_START_LOW_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LE_START_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t le_end_offset[] = {
+       CDP_S_LUT_LE_END_LOW_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LE_END_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t lo_start_offset[] = {
+       CDP_S_LUT_LO_START_LOW_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LO_START_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t lo_end_offset[] = {
+       CDP_S_LUT_LO_END_LOW_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LO_END_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t le_slope_scale_offset[] = {
+       CDP_S_LUT_LE_SLOPE_SCALE_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LE_SLOPE_SCALE_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t le_slope_shift_offset[] = {
+       CDP_S_LUT_LE_SLOPE_SHIFT_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LE_SLOPE_SHIFT_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t lo_slope_scale_offset[] = {
+       CDP_S_LUT_LO_SLOPE_SCALE_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LO_SLOPE_SCALE_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+static const uint16_t lo_slope_shift_offset[] = {
+       CDP_S_LUT_LO_SLOPE_SHIFT_0 - CDP_S_LUT_ACCESS_CFG_0,
+       SDP_S_LUT_LO_SLOPE_SHIFT_0 - SDP_S_LUT_ACCESS_CFG_0,
+};
+
+void update_lut(uint32_t reg_base, struct dla_lut_param *lut,
+                                                       uint8_t precision)
+{
+       int32_t i;
+       uint32_t reg;
+       uint32_t high, low;
+       int32_t is_sdp = reg_base == SDP_S_LUT_ACCESS_CFG_0;
+       struct dla_engine *engine = dla_get_engine();
+
+       /* program raw table */
+       reg = (FIELD_ENUM(CDP_S_LUT_ACCESS_CFG_0, LUT_TABLE_ID, LE)
+               << SHIFT(CDP_S_LUT_ACCESS_CFG_0, LUT_TABLE_ID)) |
+               (FIELD_ENUM(CDP_S_LUT_ACCESS_CFG_0, LUT_ACCESS_TYPE, WRITE)
+               << SHIFT(CDP_S_LUT_ACCESS_CFG_0, LUT_ACCESS_TYPE));
+       reg_write(reg_base, reg);
+
+       for (i = 0; i < (1<<LUT_LINEAR_EXP_TABLE_ENTRY_LOG2)+1; i++) {
+               dla_reg_write(engine->driver_context,
+                               reg_base + access_data_offset[is_sdp],
+                               lut->linear_exp_table[i]);
+       }
+
+       /* program density table */
+       reg = (FIELD_ENUM(CDP_S_LUT_ACCESS_CFG_0, LUT_TABLE_ID, LO)
+               << SHIFT(CDP_S_LUT_ACCESS_CFG_0, LUT_TABLE_ID)) |
+               (FIELD_ENUM(CDP_S_LUT_ACCESS_CFG_0, LUT_ACCESS_TYPE, WRITE)
+               << SHIFT(CDP_S_LUT_ACCESS_CFG_0, LUT_ACCESS_TYPE));
+       dla_reg_write(engine->driver_context, reg_base, reg);
+
+       for (i = 0; i < (1<<LUT_LINEAR_ONLY_TABLE_ENTRY_LOG2)+1; i++) {
+               dla_reg_write(engine->driver_context,
+                               reg_base + access_data_offset[is_sdp],
+                               lut->linear_only_table[i]);
+       }
+
+       /* program other configurations */
+       reg = (map_lut_method[lut->method] <<
+               SHIFT(CDP_S_LUT_CFG_0, LUT_LE_FUNCTION)) |
+               (map_lut_out[lut->hybrid_priority] <<
+               SHIFT(CDP_S_LUT_CFG_0, LUT_HYBRID_PRIORITY)) |
+               (map_lut_out[lut->underflow_priority] <<
+               SHIFT(CDP_S_LUT_CFG_0, LUT_UFLOW_PRIORITY)) |
+               (map_lut_out[lut->overflow_priority] <<
+               SHIFT(CDP_S_LUT_CFG_0, LUT_OFLOW_PRIORITY));
+       dla_reg_write(engine->driver_context,
+                       reg_base + lut_cfg_offset[is_sdp], reg);
+
+       if (lut->method == FIELD_ENUM(CDP_S_LUT_CFG_0,
+                                       LUT_LE_FUNCTION, EXPONENT)) {
+               reg = ((((uint32_t)lut->linear_exp_offset.exp_offset) <<
+                       SHIFT(CDP_S_LUT_INFO_0, LUT_LE_INDEX_OFFSET))&
+               MASK(CDP_S_LUT_INFO_0, LUT_LE_INDEX_OFFSET)) |
+                       ((((uint32_t)lut->linear_only_offset.frac_bits) <<
+                       SHIFT(CDP_S_LUT_INFO_0, LUT_LO_INDEX_SELECT))&
+               MASK(CDP_S_LUT_INFO_0, LUT_LO_INDEX_SELECT));
+       } else {
+               reg = ((((uint32_t)lut->linear_exp_offset.frac_bits) <<
+                       SHIFT(CDP_S_LUT_INFO_0, LUT_LE_INDEX_SELECT))&
+               MASK(CDP_S_LUT_INFO_0, LUT_LE_INDEX_SELECT)) |
+                       ((((uint32_t)lut->linear_only_offset.frac_bits) <<
+                       SHIFT(CDP_S_LUT_INFO_0, LUT_LO_INDEX_SELECT))&
+               MASK(CDP_S_LUT_INFO_0, LUT_LO_INDEX_SELECT));
+       }
+       dla_reg_write(engine->driver_context,
+                       reg_base + lut_info_offset[is_sdp], reg);
+       high = HIGH32BITS(lut->linear_exp_start);
+       low = LOW32BITS(lut->linear_exp_start);
+       dla_reg_write(engine->driver_context,
+                       reg_base + le_start_offset[is_sdp], low);
+       if (!is_sdp)
+               dla_reg_write(engine->driver_context,
+                               reg_base + le_start_offset[is_sdp] + 4, high);
+
+       high = HIGH32BITS(lut->linear_exp_end);
+       low = LOW32BITS(lut->linear_exp_end);
+       dla_reg_write(engine->driver_context,
+                               reg_base + le_end_offset[is_sdp], low);
+       if (!is_sdp)
+               dla_reg_write(engine->driver_context,
+                               reg_base + le_end_offset[is_sdp] + 4, high);
+
+       high = HIGH32BITS(lut->linear_only_start);
+       low = LOW32BITS(lut->linear_only_start);
+       dla_reg_write(engine->driver_context,
+                               reg_base + lo_start_offset[is_sdp], low);
+       if (!is_sdp)
+               dla_reg_write(engine->driver_context,
+                               reg_base + lo_start_offset[is_sdp] + 4, high);
+
+       high = HIGH32BITS(lut->linear_only_end);
+       low = LOW32BITS(lut->linear_only_end);
+       dla_reg_write(engine->driver_context,
+                               reg_base + lo_end_offset[is_sdp], low);
+       if (!is_sdp)
+               dla_reg_write(engine->driver_context,
+                               reg_base + lo_end_offset[is_sdp] + 4, high);
+
+       if (precision == PRECISION_FP16) {
+               reg = (lut->linear_exp_underflow_slope.data_f <<
+                       SHIFT(CDP_S_LUT_LE_SLOPE_SCALE_0,
+                                       LUT_LE_SLOPE_UFLOW_SCALE)) |
+                       (lut->linear_exp_overflow_slope.data_f <<
+                       SHIFT(CDP_S_LUT_LE_SLOPE_SCALE_0,
+                                       LUT_LE_SLOPE_OFLOW_SCALE));
+               dla_reg_write(engine->driver_context,
+                               reg_base + le_slope_scale_offset[is_sdp], reg);
+
+               reg = (lut->linear_only_underflow_slope.data_f <<
+                       SHIFT(CDP_S_LUT_LO_SLOPE_SCALE_0,
+                                       LUT_LO_SLOPE_UFLOW_SCALE)) |
+                       (lut->linear_only_overflow_slope.data_f <<
+                       SHIFT(CDP_S_LUT_LO_SLOPE_SCALE_0,
+                                       LUT_LO_SLOPE_OFLOW_SCALE));
+               dla_reg_write(engine->driver_context,
+                               reg_base + lo_slope_scale_offset[is_sdp], reg);
+       } else {
+               union dla_slope *oslope;
+               union dla_slope *uslope;
+
+               uslope = &lut->linear_exp_underflow_slope;
+               oslope = &lut->linear_exp_overflow_slope;
+               reg = ((((uint32_t)uslope->data_i.scale)
+                       << SHIFT(CDP_S_LUT_LE_SLOPE_SCALE_0,
+                                       LUT_LE_SLOPE_UFLOW_SCALE))&
+                       MASK(CDP_S_LUT_LE_SLOPE_SCALE_0,
+                                       LUT_LE_SLOPE_UFLOW_SCALE)) |
+                       ((((uint32_t)oslope->data_i.scale)
+                       << SHIFT(CDP_S_LUT_LE_SLOPE_SCALE_0,
+                                       LUT_LE_SLOPE_OFLOW_SCALE))&
+                       MASK(CDP_S_LUT_LE_SLOPE_SCALE_0,
+                                       LUT_LE_SLOPE_OFLOW_SCALE));
+               dla_reg_write(engine->driver_context,
+                               reg_base + le_slope_scale_offset[is_sdp], reg);
+
+               reg = ((((uint32_t)uslope->data_i.shifter) <<
+                       SHIFT(CDP_S_LUT_LE_SLOPE_SHIFT_0,
+                                       LUT_LE_SLOPE_UFLOW_SHIFT))&
+                       MASK(CDP_S_LUT_LE_SLOPE_SHIFT_0,
+                                       LUT_LE_SLOPE_UFLOW_SHIFT)) |
+                       ((((uint32_t)oslope->data_i.shifter) <<
+                       SHIFT(CDP_S_LUT_LE_SLOPE_SHIFT_0,
+                                       LUT_LE_SLOPE_OFLOW_SHIFT))&
+                       MASK(CDP_S_LUT_LE_SLOPE_SHIFT_0,
+                                       LUT_LE_SLOPE_OFLOW_SHIFT));
+               dla_reg_write(engine->driver_context,
+                               reg_base + le_slope_shift_offset[is_sdp], reg);
+
+               uslope = &lut->linear_only_underflow_slope;
+               oslope = &lut->linear_only_overflow_slope;
+               reg = ((((uint32_t)uslope->data_i.scale) <<
+                       SHIFT(CDP_S_LUT_LO_SLOPE_SCALE_0,
+                                       LUT_LO_SLOPE_UFLOW_SCALE))&
+                       MASK(CDP_S_LUT_LO_SLOPE_SCALE_0,
+                                       LUT_LO_SLOPE_UFLOW_SCALE)) |
+                       ((((uint32_t)oslope->data_i.scale) <<
+                       SHIFT(CDP_S_LUT_LO_SLOPE_SCALE_0,
+                                       LUT_LO_SLOPE_OFLOW_SCALE))&
+                       MASK(CDP_S_LUT_LO_SLOPE_SCALE_0,
+                                       LUT_LO_SLOPE_OFLOW_SCALE));
+               dla_reg_write(engine->driver_context,
+                               reg_base + lo_slope_scale_offset[is_sdp], reg);
+               reg = ((((uint32_t)uslope->data_i.shifter) <<
+                       SHIFT(CDP_S_LUT_LO_SLOPE_SHIFT_0,
+                                       LUT_LO_SLOPE_UFLOW_SHIFT))&
+                       MASK(CDP_S_LUT_LO_SLOPE_SHIFT_0,
+                                       LUT_LO_SLOPE_UFLOW_SHIFT)) |
+                       ((((uint32_t)oslope->data_i.shifter) <<
+                       SHIFT(CDP_S_LUT_LO_SLOPE_SHIFT_0,
+                                       LUT_LO_SLOPE_OFLOW_SHIFT))&
+                       MASK(CDP_S_LUT_LO_SLOPE_SHIFT_0,
+                                       LUT_LO_SLOPE_OFLOW_SHIFT));
+               dla_reg_write(engine->driver_context,
+                               reg_base + lo_slope_shift_offset[is_sdp], reg);
+       }
+}
+
+int
+validate_data_cube(struct dla_data_cube src_data_cube,
+                       struct dla_data_cube dst_data_cube,
+                       uint8_t mem_type)
+{
+       int32_t ret = 0;
+
+       dla_trace("Enter: %s", __func__);
+
+       if ((src_data_cube.width > DCUBE_MAX_WIDTH) ||
+           (src_data_cube.height > DCUBE_MAX_HEIGHT) ||
+           (src_data_cube.channel > DCUBE_MAX_CHANNEL)) {
+               dla_error("Invalid SrcInput Cude[W: %u, H: %u, C: %u]",
+                               src_data_cube.width, src_data_cube.height,
+                               src_data_cube.channel);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if ((dst_data_cube.width > DCUBE_MAX_WIDTH) ||
+           (dst_data_cube.height > DCUBE_MAX_HEIGHT) ||
+           (dst_data_cube.channel > DCUBE_MAX_CHANNEL)) {
+               dla_error("Invalid DstInput Cude[W: %u, H: %u, C: %u]",
+                               dst_data_cube.width, dst_data_cube.height,
+                               dst_data_cube.channel);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if (src_data_cube.type > mem_type) {
+               dla_error("Invalid src_data.mem_type: %u\n", src_data_cube.type);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if (dst_data_cube.type > mem_type) {
+               dla_error("Invalid dst_data.mem_type: %u\n", dst_data_cube.type);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+int
+validate_precision(uint8_t precision, uint8_t map_precision)
+{
+       int32_t ret = 0;
+
+       if (precision >= map_precision) {
+               dla_error("Invalid precision: %u\n", precision);
+               ret = ERR(INVALID_INPUT);
+       }
+
+       RETURN(ret);
+}

diff --git a/drivers/nvdla/common.h b/drivers/nvdla/common.h
new file mode 100644 (file)
index 0000000..2605cfc
--- /dev/null
+++ b/drivers/nvdla/common.h
@@ -0,0 +1,47 @@
+/*
+ * 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_COMMON_H_
+#define __FIRMWARE_COMMON_H_
+
+#include <dla_interface.h>
+
+#define DCUBE_MAX_WIDTH                8192
+#define DCUBE_MAX_HEIGHT       8192
+#define DCUBE_MAX_CHANNEL      8192
+
+void update_lut(uint32_t reg_base,
+               struct dla_lut_param *lut,
+               uint8_t precision);
+int32_t validate_data_cube(struct dla_data_cube src_data_cube,
+                       struct dla_data_cube dst_data_cube,
+                       uint8_t mem_type);
+int32_t validate_precision(uint8_t precision,
+                       uint8_t map_precision);
+
+#endif /* __FIRMWARE_COMMON_H_ */

diff --git a/drivers/nvdla/conv.c b/drivers/nvdla/conv.c
new file mode 100644 (file)
index 0000000..be62d65
--- /dev/null
+++ b/drivers/nvdla/conv.c
@@ -0,0 +1,779 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "common.h"
+#include "dla_engine_internal.h"
+#include "engine_debug.h"
+
+static const uint8_t map_precision[] = {
+       FIELD_ENUM(CDMA_D_MISC_CFG_0, IN_PRECISION, INT8),
+       FIELD_ENUM(CDMA_D_MISC_CFG_0, IN_PRECISION, INT16),
+       FIELD_ENUM(CDMA_D_MISC_CFG_0, IN_PRECISION, FP16),
+};
+
+static const uint8_t map_conv[] = {
+       FIELD_ENUM(CACC_D_MISC_CFG_0, CONV_MODE, DIRECT),
+       FIELD_ENUM(CACC_D_MISC_CFG_0, CONV_MODE, WINOGRAD),
+};
+
+static const uint8_t map_weight_fmt[] = {
+       FIELD_ENUM(CSC_D_WEIGHT_FORMAT_0, WEIGHT_FORMAT, UNCOMPRESSED),
+       FIELD_ENUM(CSC_D_WEIGHT_FORMAT_0, WEIGHT_FORMAT, COMPRESSED),
+};
+
+static const uint8_t map_img_fmt[][2] = {
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R8), 1},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R10), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R12), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R16), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R16_I), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R16_F), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A16B16G16R16), 8},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_X16B16G16R16), 8},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A16B16G16R16_F), 8},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A16Y16U16V16), 8},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_V16U16Y16A16), 8},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A16Y16U16V16_F), 8},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A8B8G8R8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A8R8G8B8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_B8G8R8A8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R8G8B8A8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_X8B8G8R8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_X8R8G8B8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_B8G8R8X8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R8G8B8X8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A2B10G10R10), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A2R10G10B10), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_B10G10R10A2), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_R10G10B10A2), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A2Y10U10V10), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_V10U10Y10A2), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_A8Y8U8V8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_V8U8Y8A8), 4},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y8___U8V8_N444), 1},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y8___V8U8_N444), 1},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y10___U10V10_N444), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y10___V10U10_N444), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y12___U12V12_N444), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y12___V12U12_N444), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y16___U16V16_N444), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       PIXEL_FORMAT, T_Y16___V16U16_N444), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       DATAIN_FORMAT, FEATURE), 2},
+       {FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                       DATAIN_FORMAT, PIXEL), 1},
+};
+
+static const uint8_t map_pixel[] = {
+       FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0, PIXEL_MAPPING, PITCH_LINEAR),
+};
+
+static const uint8_t map_ram[] = {
+       FIELD_ENUM(CDMA_D_DAIN_RAM_TYPE_0, DATAIN_RAM_TYPE, MCIF),
+       FIELD_ENUM(CDMA_D_DAIN_RAM_TYPE_0, DATAIN_RAM_TYPE, CVIF),
+};
+
+static const uint8_t map_mean[] = {
+       FIELD_ENUM(CDMA_D_MEAN_FORMAT_0, MEAN_FORMAT, DISABLE),
+       FIELD_ENUM(CDMA_D_MEAN_FORMAT_0, MEAN_FORMAT, ENABLE),
+};
+
+#if STAT_ENABLE
+void
+dla_conv_stat_data(struct dla_processor *processor,
+                                       struct dla_processor_group *group)
+{
+       uint64_t end_time = 0;
+       struct dla_conv_stat_desc *conv_stat;
+
+       conv_stat = &processor->stat_data_desc->conv_stat;
+
+       end_time = dla_get_time_us();
+
+       conv_stat->data_read_stall = cdma_reg_read(D_PERF_DAT_READ_STALL);
+       conv_stat->weight_read_stall = cdma_reg_read(D_PERF_WT_READ_STALL);
+       conv_stat->data_read_latency = cdma_reg_read(D_PERF_DAT_READ_LATENCY);
+       conv_stat->weight_read_latency = cdma_reg_read(D_PERF_WT_READ_LATENCY);
+       conv_stat->nan_data_num = cdma_reg_read(D_NAN_INPUT_DATA_NUM);
+       conv_stat->nan_weight_num = cdma_reg_read(D_NAN_INPUT_WEIGHT_NUM);
+       conv_stat->inf_data_num = cdma_reg_read(D_INF_INPUT_DATA_NUM);
+       conv_stat->inf_weight_num = cdma_reg_read(D_INF_INPUT_WEIGHT_NUM);
+       conv_stat->saturation_count = cacc_reg_read(D_OUT_SATURATION);
+       conv_stat->runtime = (uint32_t)(end_time - group->start_time);
+}
+
+void
+dla_conv_dump_stat(struct dla_processor *processor)
+{
+       struct dla_conv_stat_desc *conv_stat;
+
+       conv_stat = &processor->stat_data_desc->conv_stat;
+
+       dla_debug_conv_stats(conv_stat);
+}
+#endif /* STAT_ENABLE */
+
+static uint32_t
+get_in_format(uint8_t format)
+{
+       uint32_t in_format = 0;
+
+       if (format >= FORMAT_T_R8 && format < FORMAT_FEATURE) {
+               in_format = FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                                               DATAIN_FORMAT, PIXEL);
+       } else if (format == FORMAT_FEATURE) {
+               in_format = FIELD_ENUM(CDMA_D_DATAIN_FORMAT_0,
+                                               DATAIN_FORMAT, FEATURE);
+       } else {
+               assert(0);
+       }
+
+       return in_format;
+}
+
+void
+dla_conv_set_producer(int32_t group_id, int32_t rdma_group_id)
+{
+       uint32_t reg;
+
+       /* set producer pointer for all sub-modules */
+       reg = group_id << SHIFT(CACC_S_POINTER_0, PRODUCER);
+       cacc_reg_write(S_POINTER, reg);
+       cmac_a_reg_write(S_POINTER, reg);
+       cmac_b_reg_write(S_POINTER, reg);
+       csc_reg_write(S_POINTER, reg);
+       cdma_reg_write(S_POINTER, reg);
+}
+
+int
+dla_conv_enable(struct dla_processor_group *group)
+{
+       uint32_t reg;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_trace("Enter: %s", __func__);
+
+       do {
+               reg = cdma_reg_read(S_CBUF_FLUSH_STATUS);
+       } while (!(reg & MASK(CDMA_S_CBUF_FLUSH_STATUS_0, FLUSH_DONE)));
+
+       if (engine->stat_enable == (uint32_t)1) {
+               cdma_reg_write(D_PERF_ENABLE, 1);
+               group->start_time = dla_get_time_us();
+       }
+
+       /* enable all sub-modules */
+       reg = FIELD_ENUM(CACC_D_OP_ENABLE_0, OP_EN, ENABLE);
+       cacc_reg_write(D_OP_ENABLE, reg);
+       cmac_a_reg_write(D_OP_ENABLE, reg);
+       cmac_b_reg_write(D_OP_ENABLE, reg);
+       csc_reg_write(D_OP_ENABLE, reg);
+       cdma_reg_write(D_OP_ENABLE, reg);
+
+       dla_trace("Exit: %s", __func__);
+
+       RETURN(0);
+}
+
+void
+dla_conv_rdma_check(struct dla_processor_group *group)
+{
+       group->is_rdma_needed = 0;
+}
+
+static int32_t
+processor_conv_program(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       uint32_t reg, high, low, shift, mask;
+       uint32_t stride_x, stride_y, pad_x, pad_y;
+       uint64_t weight_address = 0;
+       uint64_t wmb_address = 0;
+       uint64_t wgs_address = 0;
+       uint64_t input_address = 0;
+       uint64_t output_address = 0;
+       uint32_t atom_size = 0;
+       bool weight_compress_support = false;
+       struct dla_engine *engine = dla_get_engine();
+       struct dla_conv_op_desc *conv_op;
+       struct dla_conv_surface_desc *conv_surface;
+
+       dla_trace("Enter: %s", __func__);
+
+       weight_compress_support = engine->config_data->weight_compress_support;
+       atom_size = engine->config_data->atom_size;
+       conv_op = &group->operation_desc->conv_op;
+       conv_surface = &group->surface_desc->conv_surface;
+
+       if (conv_op->weight_format == WEIGHT_FORMAT_COMPRESSED) {
+               ASSERT_GOTO((weight_compress_support), ret, ERR(INVALID_INPUT), exit);
+               ASSERT_GOTO((conv_surface->wmb_data.address != -1),
+                       ret, ERR(INVALID_INPUT), exit);
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       conv_surface->wmb_data.address,
+                                       conv_surface->wmb_data.offset,
+                                       (void *)&wmb_address,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(wmb_address, atom_size);
+               CHECK_ALIGN(conv_surface->wmb_data.size, 128);
+
+               ASSERT_GOTO((conv_surface->wgs_data.address != -1),
+                       ret, ERR(INVALID_INPUT), exit);
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       conv_surface->wgs_data.address,
+                                       conv_surface->wgs_data.offset,
+                                       (void *)&wgs_address,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(wgs_address, atom_size);
+               CHECK_ALIGN(conv_surface->wgs_data.size, 4);
+       }
+
+       if (conv_surface->weight_data.address != -1) {
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       conv_surface->weight_data.address,
+                                       conv_surface->weight_data.offset,
+                                       (void *)&weight_address,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(weight_address, atom_size);
+               CHECK_ALIGN(conv_surface->weight_data.size, 128);
+       }
+
+       if (conv_surface->dst_data.address != -1) {
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       conv_surface->dst_data.address,
+                                       conv_surface->dst_data.offset,
+                                       (void *)&output_address,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(output_address, atom_size);
+               CHECK_ALIGN(conv_surface->dst_data.size, atom_size);
+               CHECK_ALIGN(conv_surface->dst_data.line_stride, atom_size);
+               CHECK_ALIGN(conv_surface->dst_data.surf_stride, atom_size);
+       }
+
+       ret = dla_read_input_address(&conv_surface->src_data, &input_address,
+                                       group->op_desc->index,
+                                       group->roi_index,
+                                       map_img_fmt[conv_op->data_format][1]);
+       if (ret)
+               goto exit;
+
+       CHECK_ALIGN(input_address, atom_size);
+
+       ASSERT_GOTO((conv_op->out_cvt.scale  == 1),
+               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO((conv_op->out_cvt.offset == 0),
+               ret, ERR(INVALID_INPUT), exit);
+
+       /* check if the register group is idle */
+       reg = cacc_reg_read(S_STATUS);
+       mask = group->id ? MASK(CACC_S_STATUS_0, STATUS_1) :
+               MASK(CACC_S_STATUS_0, STATUS_0);
+       shift = group->id ? SHIFT(CACC_S_STATUS_0, STATUS_1) :
+               SHIFT(CACC_S_STATUS_0, STATUS_0);
+       reg = (reg & mask) >> shift;
+       ASSERT_GOTO((reg == FIELD_ENUM(CACC_S_STATUS_0, STATUS_0, IDLE)),
+               ret, ERR(INVALID_INPUT), exit);
+
+       reg = cmac_a_reg_read(S_STATUS);
+       mask = group->id ? MASK(CMAC_A_S_STATUS_0, STATUS_1) :
+        MASK(CMAC_A_S_STATUS_0, STATUS_0);
+       shift = group->id ? SHIFT(CMAC_A_S_STATUS_0, STATUS_1) :
+               SHIFT(CMAC_A_S_STATUS_0, STATUS_0);
+       reg = (reg & mask) >> shift;
+       ASSERT_GOTO((reg == FIELD_ENUM(CMAC_A_S_STATUS_0, STATUS_0, IDLE)),
+               ret, ERR(INVALID_INPUT), exit);
+
+       reg = cmac_b_reg_read(S_STATUS);
+       mask = group->id ? MASK(CMAC_B_S_STATUS_0, STATUS_1) :
+               MASK(CMAC_B_S_STATUS_0, STATUS_0);
+       shift = group->id ? SHIFT(CMAC_B_S_STATUS_0, STATUS_1) :
+               SHIFT(CMAC_B_S_STATUS_0, STATUS_0);
+       reg = (reg & mask) >> shift;
+       ASSERT_GOTO((reg == FIELD_ENUM(CMAC_B_S_STATUS_0, STATUS_0, IDLE)),
+               ret, ERR(INVALID_INPUT), exit);
+
+       reg = csc_reg_read(S_STATUS);
+       mask = group->id ? MASK(CSC_S_STATUS_0, STATUS_1) :
+               MASK(CSC_S_STATUS_0, STATUS_0);
+       shift = group->id ? SHIFT(CSC_S_STATUS_0, STATUS_1) :
+               SHIFT(CSC_S_STATUS_0, STATUS_0);
+       reg = (reg & mask) >> shift;
+       ASSERT_GOTO((reg == FIELD_ENUM(CSC_S_STATUS_0, STATUS_0, IDLE)),
+               ret, ERR(INVALID_INPUT), exit);
+
+       reg = cdma_reg_read(S_STATUS);
+       mask = group->id ? MASK(CDMA_S_STATUS_0, STATUS_1) :
+               MASK(CDMA_S_STATUS_0, STATUS_0);
+       shift = group->id ? SHIFT(CDMA_S_STATUS_0, STATUS_1) :
+               SHIFT(CDMA_S_STATUS_0, STATUS_0);
+       reg = (reg & mask) >> shift;
+       ASSERT_GOTO((reg == FIELD_ENUM(CDMA_S_STATUS_0, STATUS_0, IDLE)),
+               ret, ERR(INVALID_INPUT), exit);
+
+       /* reverse config each sub-module in CC */
+
+       /* CACC */
+       reg = (map_conv[conv_op->conv_mode]
+               << SHIFT(CACC_D_MISC_CFG_0, CONV_MODE)) |
+               (map_precision[conv_op->out_precision]
+               << SHIFT(CACC_D_MISC_CFG_0, PROC_PRECISION));
+       cacc_reg_write(D_MISC_CFG, reg);
+
+       reg = ((conv_surface->dst_data.width - 1)
+               << SHIFT(CACC_D_DATAOUT_SIZE_0_0, DATAOUT_WIDTH)) |
+               ((conv_surface->dst_data.height - 1)
+               << SHIFT(CACC_D_DATAOUT_SIZE_0_0, DATAOUT_HEIGHT));
+       cacc_reg_write(D_DATAOUT_SIZE_0, reg);
+
+       reg = ((conv_surface->dst_data.channel - 1)
+               << SHIFT(CACC_D_DATAOUT_SIZE_1_0, DATAOUT_CHANNEL));
+       cacc_reg_write(D_DATAOUT_SIZE_1, reg);
+
+       low = LOW32BITS(output_address);
+       cacc_reg_write(D_DATAOUT_ADDR, low);
+       cacc_reg_write(D_BATCH_NUMBER, conv_op->batch - 1);
+       cacc_reg_write(D_LINE_STRIDE, conv_surface->dst_data.line_stride);
+       cacc_reg_write(D_SURF_STRIDE, conv_surface->dst_data.surf_stride);
+
+       if (conv_surface->dst_data.width == 1 &&
+                               conv_surface->dst_data.height == 1) {
+               ASSERT_GOTO((((uint32_t)conv_surface->dst_data.line_stride ==
+                       (uint32_t)(conv_surface->dst_data.width * atom_size))),
+                       ret, ERR(INVALID_INPUT), exit);
+               reg = (CACC_D_DATAOUT_MAP_0_LINE_PACKED_TRUE <<
+                               SHIFT(CACC_D_DATAOUT_MAP_0, LINE_PACKED));
+               reg |= (CACC_D_DATAOUT_MAP_0_SURF_PACKED_TRUE <<
+                               SHIFT(CACC_D_DATAOUT_MAP_0, SURF_PACKED));
+       } else {
+               reg = (FIELD_ENUM(CACC_D_DATAOUT_MAP_0, LINE_PACKED, FALSE) <<
+                               SHIFT(CACC_D_DATAOUT_MAP_0, LINE_PACKED));
+               reg |= (FIELD_ENUM(CACC_D_DATAOUT_MAP_0, SURF_PACKED, FALSE) <<
+                               SHIFT(CACC_D_DATAOUT_MAP_0, SURF_PACKED));
+       }
+       cacc_reg_write(D_DATAOUT_MAP, reg);
+
+       cacc_reg_write(D_CLIP_CFG, conv_op->out_cvt.truncate);
+
+       /* CMAC */
+       reg = (map_conv[conv_op->conv_mode]
+               << SHIFT(CMAC_A_D_MISC_CFG_0, CONV_MODE)) |
+               (map_precision[conv_op->out_precision]
+               << SHIFT(CMAC_A_D_MISC_CFG_0, PROC_PRECISION));
+       cmac_a_reg_write(D_MISC_CFG, reg);
+       cmac_b_reg_write(D_MISC_CFG, reg);
+
+       /* CSC */
+       reg = (map_conv[conv_op->conv_mode]
+               << SHIFT(CSC_D_MISC_CFG_0, CONV_MODE)) |
+               (map_precision[conv_op->out_precision]
+               << SHIFT(CSC_D_MISC_CFG_0, IN_PRECISION)) |
+               (map_precision[conv_op->out_precision]
+               << SHIFT(CSC_D_MISC_CFG_0, PROC_PRECISION)) |
+               (conv_op->data_reuse
+               << SHIFT(CSC_D_MISC_CFG_0, DATA_REUSE)) |
+               (conv_op->weight_reuse
+               << SHIFT(CSC_D_MISC_CFG_0, WEIGHT_REUSE)) |
+               (conv_op->skip_data_rls
+               << SHIFT(CSC_D_MISC_CFG_0, SKIP_DATA_RLS)) |
+               (conv_op->skip_weight_rls
+               << SHIFT(CSC_D_MISC_CFG_0, SKIP_WEIGHT_RLS));
+       csc_reg_write(D_MISC_CFG, reg);
+
+       reg = (get_in_format(conv_op->data_format) <<
+               SHIFT(CSC_D_DATAIN_FORMAT_0, DATAIN_FORMAT));
+       csc_reg_write(D_DATAIN_FORMAT, reg);
+
+       reg = ((conv_op->input_width_csc - 1)
+               << SHIFT(CSC_D_DATAIN_SIZE_EXT_0_0, DATAIN_WIDTH_EXT)) |
+               ((conv_op->input_height_csc - 1)
+               << SHIFT(CSC_D_DATAIN_SIZE_EXT_0_0, DATAIN_HEIGHT_EXT));
+       csc_reg_write(D_DATAIN_SIZE_EXT_0, reg);
+
+       reg = ((conv_op->input_channel_csc - 1)
+               << SHIFT(CSC_D_DATAIN_SIZE_EXT_1_0, DATAIN_CHANNEL_EXT));
+       csc_reg_write(D_DATAIN_SIZE_EXT_1, reg);
+
+       reg = ((conv_op->batch - 1)
+               << SHIFT(CSC_D_BATCH_NUMBER_0, BATCHES));
+       csc_reg_write(D_BATCH_NUMBER, reg);
+       reg = ((conv_op->post_extension)
+               << SHIFT(CSC_D_POST_Y_EXTENSION_0, Y_EXTENSION));
+       csc_reg_write(D_POST_Y_EXTENSION, reg);
+
+       reg = ((conv_op->entry_per_slice - 1)
+               << SHIFT(CSC_D_ENTRY_PER_SLICE_0, ENTRIES));
+       csc_reg_write(D_ENTRY_PER_SLICE, reg);
+
+       reg = (map_weight_fmt[conv_op->weight_format]
+               << SHIFT(CSC_D_WEIGHT_FORMAT_0, WEIGHT_FORMAT));
+       csc_reg_write(D_WEIGHT_FORMAT, reg);
+
+       reg = ((conv_op->kernel_width_csc - 1)
+               << SHIFT(CSC_D_WEIGHT_SIZE_EXT_0_0, WEIGHT_WIDTH_EXT)) |
+               ((conv_op->kernel_height_csc - 1)
+               << SHIFT(CSC_D_WEIGHT_SIZE_EXT_0_0, WEIGHT_HEIGHT_EXT));
+       csc_reg_write(D_WEIGHT_SIZE_EXT_0, reg);
+
+       reg = ((conv_op->kernel_channel_csc - 1)
+               << SHIFT(CSC_D_WEIGHT_SIZE_EXT_1_0, WEIGHT_CHANNEL_EXT)) |
+               ((conv_surface->dst_data.channel - 1)
+               << SHIFT(CSC_D_WEIGHT_SIZE_EXT_1_0, WEIGHT_KERNEL));
+       csc_reg_write(D_WEIGHT_SIZE_EXT_1, reg);
+
+       csc_reg_write(D_WEIGHT_BYTES, conv_surface->weight_data.size);
+       csc_reg_write(D_WMB_BYTES, conv_surface->wmb_data.size);
+
+       reg = ((conv_op->input_width_cmac - 1)
+               << SHIFT(CSC_D_DATAOUT_SIZE_0_0, DATAOUT_WIDTH)) |
+               ((conv_op->input_height_cmac - 1)
+               << SHIFT(CSC_D_DATAOUT_SIZE_0_0, DATAOUT_HEIGHT));
+       csc_reg_write(D_DATAOUT_SIZE_0, reg);
+
+       reg = ((conv_surface->dst_data.channel - 1)
+               << SHIFT(CSC_D_DATAOUT_SIZE_1_0, DATAOUT_CHANNEL));
+       csc_reg_write(D_DATAOUT_SIZE_1, reg);
+
+       reg = ((conv_surface->dst_data.width *
+                               conv_surface->dst_data.height - 1)
+               << SHIFT(CSC_D_ATOMICS_0, ATOMICS));
+       csc_reg_write(D_ATOMICS, reg);
+       reg = ((conv_op->release - 1)
+               << SHIFT(CSC_D_RELEASE_0, RLS_SLICES));
+       csc_reg_write(D_RELEASE, reg);
+
+       if (conv_op->conv_mode == CONV_MODE_DIRECT) {
+               stride_x = conv_op->conv_stride_x - 1;
+               stride_y = conv_op->conv_stride_y - 1;
+               pad_x = conv_op->pad_x_left;
+               pad_y = conv_op->pad_y_top;
+       } else {
+               stride_x = 0;
+               stride_y = 0;
+               pad_x = 0;
+               pad_y = 0;
+       }
+
+       reg = (stride_x
+               << SHIFT(CSC_D_CONV_STRIDE_EXT_0, CONV_X_STRIDE_EXT)) |
+               (stride_y
+               << SHIFT(CSC_D_CONV_STRIDE_EXT_0, CONV_Y_STRIDE_EXT));
+       csc_reg_write(D_CONV_STRIDE_EXT, reg);
+
+       reg = ((conv_op->dilation_x - 1)
+               << SHIFT(CSC_D_DILATION_EXT_0, X_DILATION_EXT)) |
+               ((conv_op->dilation_y - 1)
+               << SHIFT(CSC_D_DILATION_EXT_0, Y_DILATION_EXT));
+       csc_reg_write(D_DILATION_EXT, reg);
+
+       reg = (pad_x
+               << SHIFT(CSC_D_ZERO_PADDING_0, PAD_LEFT)) |
+               (pad_y
+               << SHIFT(CSC_D_ZERO_PADDING_0, PAD_TOP));
+       csc_reg_write(D_ZERO_PADDING, reg);
+
+       reg = (conv_op->pad_val
+               << SHIFT(CSC_D_ZERO_PADDING_VALUE_0, PAD_VALUE)) &
+               MASK(CSC_D_ZERO_PADDING_VALUE_0, PAD_VALUE);
+       csc_reg_write(D_ZERO_PADDING_VALUE, reg);
+
+       reg = ((conv_op->data_bank - 1)
+               << SHIFT(CSC_D_BANK_0, DATA_BANK)) |
+               ((conv_op->weight_bank - 1)
+               << SHIFT(CSC_D_BANK_0, WEIGHT_BANK));
+       csc_reg_write(D_BANK, reg);
+       csc_reg_write(D_PRA_CFG, conv_op->pra_truncate);
+
+       /* CBUF */
+       /* there's no CBUF register */
+
+       /* CDMA */
+       reg = (map_conv[conv_op->conv_mode]
+               << SHIFT(CDMA_D_MISC_CFG_0, CONV_MODE)) |
+               (map_precision[conv_op->in_precision]
+               << SHIFT(CDMA_D_MISC_CFG_0, IN_PRECISION)) |
+               (map_precision[conv_op->out_precision]
+               << SHIFT(CDMA_D_MISC_CFG_0, PROC_PRECISION)) |
+               (conv_op->data_reuse
+               << SHIFT(CDMA_D_MISC_CFG_0, DATA_REUSE)) |
+               (conv_op->weight_reuse
+               << SHIFT(CDMA_D_MISC_CFG_0, WEIGHT_REUSE)) |
+               (conv_op->skip_data_rls
+               << SHIFT(CDMA_D_MISC_CFG_0, SKIP_DATA_RLS)) |
+               (conv_op->skip_weight_rls
+               << SHIFT(CDMA_D_MISC_CFG_0, SKIP_WEIGHT_RLS));
+       cdma_reg_write(D_MISC_CFG, reg);
+
+       reg = (get_in_format(conv_op->data_format) <<
+               SHIFT(CDMA_D_DATAIN_FORMAT_0, DATAIN_FORMAT)) |
+               (map_img_fmt[conv_op->data_format][0]
+               << SHIFT(CDMA_D_DATAIN_FORMAT_0, PIXEL_FORMAT)) |
+               (map_pixel[conv_op->pixel_mapping]
+               << SHIFT(CDMA_D_DATAIN_FORMAT_0, PIXEL_MAPPING)) |
+               (conv_op->pixel_override
+               << SHIFT(CDMA_D_DATAIN_FORMAT_0, PIXEL_SIGN_OVERRIDE));
+       cdma_reg_write(D_DATAIN_FORMAT, reg);
+
+       reg = ((conv_surface->src_data.width - 1)
+               << SHIFT(CDMA_D_DATAIN_SIZE_0_0, DATAIN_WIDTH)) |
+               ((conv_surface->src_data.height - 1)
+               << SHIFT(CDMA_D_DATAIN_SIZE_0_0, DATAIN_HEIGHT));
+       cdma_reg_write(D_DATAIN_SIZE_0, reg);
+
+       reg = ((conv_surface->src_data.channel - 1)
+               << SHIFT(CDMA_D_DATAIN_SIZE_1_0, DATAIN_CHANNEL));
+       cdma_reg_write(D_DATAIN_SIZE_1, reg);
+
+       reg = ((conv_op->input_width_csc - 1)
+               << SHIFT(CDMA_D_DATAIN_SIZE_EXT_0_0, DATAIN_WIDTH_EXT)) |
+               ((conv_op->input_height_csc - 1)
+               << SHIFT(CDMA_D_DATAIN_SIZE_EXT_0_0, DATAIN_HEIGHT_EXT));
+       cdma_reg_write(D_DATAIN_SIZE_EXT_0, reg);
+
+       reg = (map_ram[conv_surface->src_data.type]
+               << SHIFT(CDMA_D_DAIN_RAM_TYPE_0, DATAIN_RAM_TYPE));
+       cdma_reg_write(D_DAIN_RAM_TYPE, reg);
+
+       high = HIGH32BITS(input_address);
+       low = LOW32BITS(input_address);
+       cdma_reg_write(D_DAIN_ADDR_HIGH_0, high);
+       cdma_reg_write(D_DAIN_ADDR_LOW_0, low);
+
+       high = HIGH32BITS((input_address + conv_surface->offset_u));
+       low = LOW32BITS(input_address + conv_surface->offset_u);
+       cdma_reg_write(D_DAIN_ADDR_HIGH_1, high);
+       cdma_reg_write(D_DAIN_ADDR_LOW_1, low);
+
+       cdma_reg_write(D_LINE_STRIDE, conv_surface->src_data.line_stride);
+       cdma_reg_write(D_SURF_STRIDE, conv_surface->src_data.surf_stride);
+       cdma_reg_write(D_LINE_UV_STRIDE, conv_surface->in_line_uv_stride);
+
+       reg = ((conv_surface->src_data.line_stride ==
+                       ((uint32_t)conv_surface->src_data.width * atom_size))
+               << SHIFT(CDMA_D_DAIN_MAP_0, LINE_PACKED));
+       reg |= ((conv_surface->src_data.surf_stride ==
+                       ((uint32_t)(conv_surface->src_data.width *
+                       conv_surface->src_data.height) * atom_size))
+               << SHIFT(CDMA_D_DAIN_MAP_0, SURF_PACKED));
+       cdma_reg_write(D_DAIN_MAP, reg);
+
+       reg = ((conv_op->batch - 1)
+               << SHIFT(CDMA_D_BATCH_NUMBER_0, BATCHES));
+       cdma_reg_write(D_BATCH_NUMBER, reg);
+
+       cdma_reg_write(D_BATCH_STRIDE, conv_op->batch_stride);
+
+       reg = ((conv_op->entry_per_slice - 1)
+               << SHIFT(CDMA_D_ENTRY_PER_SLICE_0, ENTRIES));
+       cdma_reg_write(D_ENTRY_PER_SLICE, reg);
+
+       reg = ((conv_op->fetch_grain - 1)
+               << SHIFT(CDMA_D_FETCH_GRAIN_0, GRAINS));
+       cdma_reg_write(D_FETCH_GRAIN, reg);
+
+       reg = (map_weight_fmt[conv_op->weight_format]
+               << SHIFT(CDMA_D_WEIGHT_FORMAT_0, WEIGHT_FORMAT));
+       cdma_reg_write(D_WEIGHT_FORMAT, reg);
+
+       reg = ((conv_op->bytes_per_kernel - 1)
+               << SHIFT(CDMA_D_WEIGHT_SIZE_0_0, BYTE_PER_KERNEL));
+       cdma_reg_write(D_WEIGHT_SIZE_0, reg);
+
+       reg = ((conv_surface->dst_data.channel - 1)
+               << SHIFT(CDMA_D_WEIGHT_SIZE_1_0, WEIGHT_KERNEL));
+       cdma_reg_write(D_WEIGHT_SIZE_1, reg);
+
+       reg = (map_ram[conv_surface->weight_data.type]
+               << SHIFT(CDMA_D_WEIGHT_RAM_TYPE_0, WEIGHT_RAM_TYPE));
+       cdma_reg_write(D_WEIGHT_RAM_TYPE, reg);
+
+       high = HIGH32BITS(weight_address);
+       low = LOW32BITS(weight_address);
+       cdma_reg_write(D_WEIGHT_ADDR_HIGH, high);
+       cdma_reg_write(D_WEIGHT_ADDR_LOW, low);
+       cdma_reg_write(D_WEIGHT_BYTES, conv_surface->weight_data.size);
+
+       if (conv_op->weight_format == WEIGHT_FORMAT_COMPRESSED) {
+               high = HIGH32BITS(wgs_address);
+               low = LOW32BITS(wgs_address);
+               cdma_reg_write(D_WGS_ADDR_HIGH, high);
+               cdma_reg_write(D_WGS_ADDR_LOW, low);
+
+               high = HIGH32BITS(wmb_address);
+               low = LOW32BITS(wmb_address);
+               cdma_reg_write(D_WMB_ADDR_HIGH, high);
+               cdma_reg_write(D_WMB_ADDR_LOW, low);
+               cdma_reg_write(D_WMB_BYTES, conv_surface->wmb_data.size);
+       }
+
+       reg = (map_mean[conv_op->mean_format]
+               << SHIFT(CDMA_D_MEAN_FORMAT_0, MEAN_FORMAT));
+       cdma_reg_write(D_MEAN_FORMAT, reg);
+
+       if (conv_op->mean_format == MEAN_FORMAT_ENABLE) {
+               reg = ((conv_op->mean_ry
+                       << SHIFT(CDMA_D_MEAN_GLOBAL_0_0, MEAN_RY)) &
+                       MASK(CDMA_D_MEAN_GLOBAL_0_0, MEAN_RY)) |
+                       ((conv_op->mean_gu
+                       << SHIFT(CDMA_D_MEAN_GLOBAL_0_0, MEAN_GU)) &
+                       MASK(CDMA_D_MEAN_GLOBAL_0_0, MEAN_GU));
+               cdma_reg_write(D_MEAN_GLOBAL_0, reg);
+
+               reg = ((conv_op->mean_bv
+                       << SHIFT(CDMA_D_MEAN_GLOBAL_1_0, MEAN_BV))&
+                       MASK(CDMA_D_MEAN_GLOBAL_1_0, MEAN_BV)) |
+                       ((conv_op->mean_ax
+                       << SHIFT(CDMA_D_MEAN_GLOBAL_1_0, MEAN_AX))&
+                       MASK(CDMA_D_MEAN_GLOBAL_1_0, MEAN_AX));
+               cdma_reg_write(D_MEAN_GLOBAL_1, reg);
+       }
+
+       if (conv_op->in_cvt.enable) {
+               reg = ((FIELD_ENUM(CDMA_D_CVT_CFG_0, CVT_EN, ENABLE))
+                       << SHIFT(CDMA_D_CVT_CFG_0, CVT_EN)) |
+                       (conv_op->in_cvt.truncate
+                       << SHIFT(CDMA_D_CVT_CFG_0, CVT_TRUNCATE));
+               cdma_reg_write(D_CVT_CFG, reg);
+               cdma_reg_write(D_CVT_OFFSET, conv_op->in_cvt.offset);
+               cdma_reg_write(D_CVT_SCALE, conv_op->in_cvt.scale);
+       } else {
+               reg = ((FIELD_ENUM(CDMA_D_CVT_CFG_0, CVT_EN, DISABLE))
+                       << SHIFT(CDMA_D_CVT_CFG_0, CVT_EN));
+               cdma_reg_write(D_CVT_CFG, reg);
+       }
+
+       reg = ((conv_op->conv_stride_x - 1)
+               << SHIFT(CDMA_D_CONV_STRIDE_0, CONV_X_STRIDE)) |
+               ((conv_op->conv_stride_y - 1)
+               << SHIFT(CDMA_D_CONV_STRIDE_0, CONV_Y_STRIDE));
+       cdma_reg_write(D_CONV_STRIDE, reg);
+
+       reg = (conv_op->pad_x_left <<
+               SHIFT(CDMA_D_ZERO_PADDING_0, PAD_LEFT)) |
+               (conv_op->pad_x_right
+               << SHIFT(CDMA_D_ZERO_PADDING_0, PAD_RIGHT)) |
+               (conv_op->pad_y_top
+               << SHIFT(CDMA_D_ZERO_PADDING_0, PAD_TOP)) |
+               (conv_op->pad_y_bottom
+               << SHIFT(CDMA_D_ZERO_PADDING_0, PAD_BOTTOM));
+       cdma_reg_write(D_ZERO_PADDING,   reg);
+
+       reg = conv_op->pad_val <<
+               SHIFT(CDMA_D_ZERO_PADDING_VALUE_0, PAD_VALUE) &
+               MASK(CDMA_D_ZERO_PADDING_VALUE_0, PAD_VALUE);
+       cdma_reg_write(D_ZERO_PADDING_VALUE, reg);
+       reg = ((conv_op->weight_bank - 1)
+               << SHIFT(CDMA_D_BANK_0, WEIGHT_BANK)) |
+               ((conv_op->data_bank - 1)
+               << SHIFT(CDMA_D_BANK_0, DATA_BANK));
+       cdma_reg_write(D_BANK, reg);
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+int
+dla_conv_is_ready(struct dla_processor *processor,
+                           struct dla_processor_group *group)
+{
+       return 1;
+}
+
+void
+dla_conv_dump_config(struct dla_processor_group *group)
+{
+       struct dla_conv_op_desc *conv_op;
+       struct dla_conv_surface_desc *conv_surface;
+
+       conv_surface = &group->surface_desc->conv_surface;
+       conv_op = &group->operation_desc->conv_op;
+
+       dla_debug_conv_surface_desc(conv_surface, group->roi_index);
+       dla_debug_conv_op_desc(conv_op, group->roi_index);
+}
+
+int
+dla_conv_program(struct dla_processor_group *group)
+{
+       int32_t ret;
+
+       dla_trace("Enter: %s", __func__);
+
+       ret = processor_conv_program(group);
+       if (ret)
+               goto exit;
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}

diff --git a/drivers/nvdla/dla_engine_internal.h b/drivers/nvdla/dla_engine_internal.h
new file mode 100644 (file)
index 0000000..d29c7b4
--- /dev/null
+++ b/drivers/nvdla/dla_engine_internal.h
@@ -0,0 +1,361 @@
+/*
+ * 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_ENGINE_INTERNAL_H_
+#define __FIRMWARE_DLA_ENGINE_INTERNAL_H_
+
+#include <opendla.h>
+#include <dla_engine.h>
+#include <dla_interface.h>
+#include <dla_debug.h>
+
+#include "nvdla_interface.h"
+
+#define BITS(num, range) ((((0xFFFFFFFF >> (31 - (1 ? range))) & \
+                       (0xFFFFFFFF << (0 ? range))) & num) >> \
+                       (0 ? range))
+#define HIGH32BITS(val64bit) ((uint32_t)(val64bit >> 32))
+#define LOW32BITS(val64bit) ((uint32_t)(val64bit))
+
+#ifdef MIN
+#undef MIN
+#endif /* MIN */
+
+#ifdef MAX
+#undef MAX
+#endif /* MAX */
+
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+/*********************************************************/
+/******************** Utilities **************************/
+/*********************************************************/
+#ifdef DEBUG
+#define CHECK_ALIGN(val, align)                 assert((val&(align-1)) == 0)
+#else
+#define CHECK_ALIGN(val, align)
+#endif /* DEBUG */
+
+#define MASK(reg, field)               (reg##_##field##_FIELD)
+#define FIELD_ENUM(r, f, e)            (r##_##f##_##e)
+#define SHIFT(reg, field)              (reg##_##field##_SHIFT)
+
+#define GLB_REG(name)                GLB_##name##_0
+#define MCIF_REG(name)               MCIF_##name##_0
+#define CVIF_REG(name)               CVIF_##name##_0
+#define BDMA_REG(name)               BDMA_##name##_0
+#define CDMA_REG(name)               CDMA_##name##_0
+#define CSC_REG(name)                CSC_##name##_0
+#define CMAC_A_REG(name)             CMAC_A_##name##_0
+#define CMAC_B_REG(name)             CMAC_B_##name##_0
+#define CACC_REG(name)               CACC_##name##_0
+#define SDP_RDMA_REG(name)           SDP_RDMA_##name##_0
+#define SDP_REG(name)                SDP_##name##_0
+#define PDP_RDMA_REG(name)           PDP_RDMA_##name##_0
+#define PDP_REG(name)                PDP_##name##_0
+#define CDP_RDMA_REG(name)           CDP_RDMA_##name##_0
+#define CDP_REG(name)                CDP_##name##_0
+#define RBK_REG(name)                RBK_##name##_0
+
+/* alias for register read for each sub-module */
+#define glb_reg_read(reg)           reg_read(GLB_REG(reg))
+#define bdma_reg_read(reg)          reg_read(BDMA_REG(reg))
+#define cdma_reg_read(reg)          reg_read(CDMA_REG(reg))
+#define csc_reg_read(reg)           reg_read(CSC_REG(reg))
+#define cmac_a_reg_read(reg)        reg_read(CMAC_A_REG(reg))
+#define cmac_b_reg_read(reg)        reg_read(CMAC_B_REG(reg))
+#define cacc_reg_read(reg)          reg_read(CACC_REG(reg))
+#define sdp_rdma_reg_read(reg)      reg_read(SDP_RDMA_REG(reg))
+#define sdp_reg_read(reg)           reg_read(SDP_REG(reg))
+#define pdp_rdma_reg_read(reg)      reg_read(PDP_RDMA_REG(reg))
+#define pdp_reg_read(reg)           reg_read(PDP_REG(reg))
+#define cdp_rdma_reg_read(reg)      reg_read(CDP_RDMA_REG(reg))
+#define cdp_reg_read(reg)           reg_read(CDP_REG(reg))
+#define rubik_reg_read(reg)         reg_read(RBK_REG(reg))
+
+/* alias for register write for each sub-module */
+#define glb_reg_write(reg, val)      reg_write(GLB_REG(reg), val)
+#define bdma_reg_write(reg, val)     reg_write(BDMA_REG(reg), val)
+#define cdma_reg_write(reg, val)     reg_write(CDMA_REG(reg), val)
+#define csc_reg_write(reg, val)      reg_write(CSC_REG(reg), val)
+#define cmac_a_reg_write(reg, val)   reg_write(CMAC_A_REG(reg), val)
+#define cmac_b_reg_write(reg, val)   reg_write(CMAC_B_REG(reg), val)
+#define cacc_reg_write(reg, val)     reg_write(CACC_REG(reg), val)
+#define sdp_rdma_reg_write(reg, val) reg_write(SDP_RDMA_REG(reg), val)
+#define sdp_reg_write(reg, val)      reg_write(SDP_REG(reg), val)
+#define pdp_rdma_reg_write(reg, val) reg_write(PDP_RDMA_REG(reg), val)
+#define pdp_reg_write(reg, val)      reg_write(PDP_REG(reg), val)
+#define cdp_rdma_reg_write(reg, val) reg_write(CDP_RDMA_REG(reg), val)
+#define cdp_reg_write(reg, val)      reg_write(CDP_REG(reg), val)
+#define rubik_reg_write(reg, val)    reg_write(RBK_REG(reg), val)
+
+void reg_write(uint32_t addr, uint32_t reg);
+uint32_t reg_read(uint32_t addr);
+
+/**
+ * Operation descriptor cache functions
+ */
+void
+dla_put_op_desc(struct dla_common_op_desc *op_desc);
+struct dla_common_op_desc
+*dla_get_op_desc(struct dla_task *task,
+                          int16_t index,
+                          uint8_t op_type,
+                          uint8_t roi_index);
+void
+dla_dump_op_desc(struct dla_common_op_desc *desc);
+void
+dla_get_refcount(struct dla_common_op_desc *op_desc);
+void
+dla_init_op_cache(struct dla_engine *engine);
+
+/**
+ * Operation completion handler
+ */
+int
+dla_op_completion(struct dla_processor *processor,
+                     struct dla_processor_group *group);
+
+int32_t
+dla_read_lut(struct dla_engine *engine, int16_t index, void *dst);
+int
+dla_enable_intr(uint32_t mask);
+int
+dla_disable_intr(uint32_t mask);
+int
+utils_get_free_group(struct dla_processor *processor,
+                       uint8_t *group_id,
+                       uint8_t *rdma_id);
+int32_t
+dla_get_dma_cube_address(void *driver_context,
+                                               void *task_data,
+                                               int16_t index,
+                                               uint32_t offset,
+                                               void *dst_ptr,
+                                               uint32_t destination);
+int
+dla_read_input_address(struct dla_data_cube *data,
+                      uint64_t *address,
+                      int16_t op_index,
+                      uint8_t roi_index,
+                      uint8_t bpp);
+
+/**
+ * BDMA operations
+ */
+void
+dla_bdma_set_producer(int32_t group_id, int32_t rdma_group_id);
+int
+dla_bdma_enable(struct dla_processor_group *group);
+int
+dla_bdma_program(struct dla_processor_group *group);
+int
+dla_bdma_is_ready(struct dla_processor *processor,
+                           struct dla_processor_group *group);
+void
+dla_bdma_dump_config(struct dla_processor_group *group);
+void
+dla_bdma_rdma_check(struct dla_processor_group *group);
+
+#if STAT_ENABLE
+void
+dla_bdma_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group);
+void
+dla_bdma_dump_stat(struct dla_processor *processor);
+
+#else
+static inline void
+dla_bdma_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group) {}
+static inline void
+dla_bdma_dump_stat(struct dla_processor *processor) {}
+#endif
+
+/**
+ * Convolution operations
+ */
+void
+dla_conv_set_producer(int32_t group_id, int32_t rdma_group_id);
+int
+dla_conv_enable(struct dla_processor_group *group);
+int
+dla_conv_program(struct dla_processor_group *group);
+int
+dla_conv_is_ready(struct dla_processor *processor,
+                           struct dla_processor_group *group);
+void
+dla_conv_dump_config(struct dla_processor_group *group);
+void
+dla_conv_rdma_check(struct dla_processor_group *group);
+
+#if STAT_ENABLE
+void
+dla_conv_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group);
+void
+dla_conv_dump_stat(struct dla_processor *processor);
+
+#else
+static inline void
+dla_conv_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group) {}
+static inline void
+dla_conv_dump_stat(struct dla_processor *processor) {}
+#endif /* STAT_ENABLE */
+
+/**
+ * SDP operations
+ */
+void
+dla_sdp_set_producer(int32_t group_id, int32_t rdma_group_id);
+int
+dla_sdp_enable(struct dla_processor_group *group);
+int
+dla_sdp_program(struct dla_processor_group *group);
+int
+dla_sdp_is_ready(struct dla_processor *processor,
+                          struct dla_processor_group *group);
+void
+dla_sdp_dump_config(struct dla_processor_group *group);
+void
+dla_sdp_rdma_check(struct dla_processor_group *group);
+
+#if STAT_ENABLE
+void
+dla_sdp_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group);
+void
+dla_sdp_dump_stat(struct dla_processor *processor);
+
+#else
+static inline void
+dla_sdp_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group) {}
+static inline void
+dla_sdp_dump_stat(struct dla_processor *processor) {}
+#endif
+
+/**
+ * PDP operations
+ */
+void
+dla_pdp_set_producer(int32_t group_id, int32_t rdma_group_id);
+int
+dla_pdp_enable(struct dla_processor_group *group);
+int
+dla_pdp_program(struct dla_processor_group *group);
+int
+dla_pdp_is_ready(struct dla_processor *processor,
+                          struct dla_processor_group *group);
+void
+dla_pdp_dump_config(struct dla_processor_group *group);
+void
+dla_pdp_rdma_check(struct dla_processor_group *group);
+
+#if STAT_ENABLE
+void
+dla_pdp_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group);
+void
+dla_pdp_dump_stat(struct dla_processor *processor);
+
+#else
+static inline void
+dla_pdp_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group) {}
+static inline void
+dla_pdp_dump_stat(struct dla_processor *processor) {}
+#endif
+
+/**
+ * CDP operations
+ */
+void
+dla_cdp_set_producer(int32_t group_id, int32_t rdma_group_id);
+int
+dla_cdp_enable(struct dla_processor_group *group);
+int
+dla_cdp_program(struct dla_processor_group *group);
+int
+dla_cdp_is_ready(struct dla_processor *processor,
+                          struct dla_processor_group *group);
+void
+dla_cdp_dump_config(struct dla_processor_group *group);
+void
+dla_cdp_rdma_check(struct dla_processor_group *group);
+
+#if STAT_ENABLE
+void
+dla_cdp_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group);
+void
+dla_cdp_dump_stat(struct dla_processor *processor);
+
+#else
+static inline void
+dla_cdp_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group) {}
+static inline void
+dla_cdp_dump_stat(struct dla_processor *processor) {}
+#endif
+
+/**
+ * RUBIK operations
+ */
+void
+dla_rubik_set_producer(int32_t group_id, int32_t rdma_group_id);
+int
+dla_rubik_enable(struct dla_processor_group *group);
+int
+dla_rubik_program(struct dla_processor_group *group);
+int
+dla_rubik_is_ready(struct dla_processor *processor,
+                            struct dla_processor_group *group);
+void
+dla_rubik_dump_config(struct dla_processor_group *group);
+void
+dla_rubik_rdma_check(struct dla_processor_group *group);
+
+#if STAT_ENABLE
+void
+dla_rubik_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group);
+void
+dla_rubik_dump_stat(struct dla_processor *processor);
+
+#else
+static inline void
+dla_rubik_stat_data(struct dla_processor *processor,
+                               struct dla_processor_group *group) {}
+static inline void
+dla_rubik_dump_stat(struct dla_processor *processor) {}
+#endif
+
+#endif

diff --git a/drivers/nvdla/engine.c b/drivers/nvdla/engine.c
new file mode 100644 (file)
index 0000000..5d2ca27
--- /dev/null
+++ b/drivers/nvdla/engine.c
@@ -0,0 +1,266 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "dla_engine_internal.h"
+#include "common.h"
+
+static const uint32_t map_rdma_ptr_addr[] = {
+       0xFFFFFFFF,
+       0xFFFFFFFF,
+       SDP_REG(RDMA_S_POINTER),
+       PDP_REG(RDMA_S_POINTER),
+       CDP_REG(RDMA_S_POINTER),
+       0xFFFFFFFF,
+};
+
+/*
+static const uint32_t map_sts_addr[] = {
+       BDMA_REG(STATUS),
+       CACC_REG(S_STATUS),
+       SDP_REG(S_STATUS),
+       PDP_REG(S_STATUS),
+       CDP_REG(S_STATUS),
+       RBK_REG(S_STATUS),
+};
+*/
+
+static const uint32_t map_ptr_addr[] = {
+       BDMA_REG(STATUS),
+       CACC_REG(S_POINTER),
+       SDP_REG(S_POINTER),
+       PDP_REG(S_POINTER),
+       CDP_REG(S_POINTER),
+       RBK_REG(S_POINTER),
+};
+
+int32_t dla_enable_intr(uint32_t mask)
+{
+       uint32_t reg = glb_reg_read(S_INTR_MASK);
+
+       reg = reg & (~mask);
+       glb_reg_write(S_INTR_MASK, reg);
+
+       RETURN(0);
+}
+
+int32_t dla_disable_intr(uint32_t mask)
+{
+       uint32_t reg = glb_reg_read(S_INTR_MASK);
+
+       reg = reg | mask;
+       glb_reg_write(S_INTR_MASK, reg);
+
+       RETURN(0);
+}
+
+/*
+uint8_t bdma_grp_sts[2] = {
+       FIELD_ENUM(BDMA_STATUS_0, IDLE, YES),
+       FIELD_ENUM(BDMA_STATUS_0, IDLE, YES)
+};
+*/
+
+struct dla_roi_desc roi_desc;
+
+/*
+ * Get DMA data cube address
+ */
+int32_t
+dla_get_dma_cube_address(void *driver_context, void *task_data,
+                                       int16_t index, uint32_t offset, void *dst_ptr,
+                                       uint32_t destination)
+{
+       int32_t ret = 0;
+       uint64_t *pdst = (uint64_t *)dst_ptr;
+       ret = dla_get_dma_address(driver_context, task_data, index,
+                                                               dst_ptr, destination);
+       if (ret)
+               goto exit;
+
+       pdst[0] += offset;
+
+exit:
+       return ret;
+}
+
+/*
+ * Read input buffer address
+ *
+ * For input layer, in case of static ROI this address is read
+ * from address list and index is specified in data cube. In case
+ * dynamic ROI, it has to be read depending on ROI information
+ * and using surface address
+ *
+ * For all other layers, this address is read from address list
+ * using index specified in data cube
+ */
+int
+dla_read_input_address(struct dla_data_cube *data,
+                      uint64_t *address,
+                      int16_t op_index,
+                      uint8_t roi_index,
+                      uint8_t bpp)
+{
+       uint64_t roi_desc_addr;
+       int32_t ret = ERR(INVALID_INPUT);
+       struct dla_engine *en = dla_get_engine();
+
+       /*
+        * If memory type is HW then no address required
+        */
+       if (data->type == DLA_MEM_HW) {
+               ret = 0;
+               goto exit;
+       }
+
+       /*
+        * If address list index is not -1 means this address has to
+        * be read from address list
+        */
+       if (data->address != -1) {
+
+               /*
+                * But if other parameters indicate that this is input layer
+                * for dynamic ROI then it is an error
+                */
+               if (en->network->dynamic_roi &&
+                       en->network->input_layer == op_index)
+                       goto exit;
+               ret = dla_get_dma_cube_address(en->driver_context,
+                                               en->task->task_data,
+                                               data->address,
+                                               data->offset,
+                                               (void *)address,
+                                               DESTINATION_DMA);
+               goto exit;
+       }
+
+       /*
+        * Check if it is dynamic ROI and this is input layer
+        */
+       if (en->network->dynamic_roi && en->network->input_layer == op_index) {
+               if (!en->task->surface_addr)
+                       goto exit;
+
+               /* Calculate address of ROI descriptor in array */
+               roi_desc_addr = en->task->roi_array_addr;
+
+               /* Read ROI descriptor */
+               ret = dla_data_read(en->driver_context,
+                               en->task->task_data,
+                               roi_desc_addr,
+                               (void *)&roi_desc,
+                               sizeof(roi_desc),
+                               sizeof(struct dla_roi_array_desc) +
+                               roi_index * sizeof(struct dla_roi_desc));
+               if (ret)
+                       goto exit;
+
+               /* Calculate ROI address */
+               *address = en->task->surface_addr;
+               *address += (roi_desc.top * data->line_stride) +
+                                               (bpp * roi_desc.left);
+       }
+
+exit:
+       RETURN(ret);
+}
+
+int
+utils_get_free_group(struct dla_processor *processor,
+                    uint8_t *group_id,
+                    uint8_t *rdma_id)
+{
+       int32_t ret = 0;
+       uint32_t pointer;
+       uint32_t hw_consumer_ptr;
+       uint32_t hw_rdma_ptr;
+
+       hw_rdma_ptr = 0;
+
+       if (processor->op_type == DLA_OP_BDMA) {
+               pointer = reg_read(map_ptr_addr[processor->op_type]);
+               hw_consumer_ptr = ((pointer & MASK(BDMA_STATUS_0, GRP0_BUSY)) >>
+                               SHIFT(BDMA_STATUS_0, GRP0_BUSY)) ==
+                               FIELD_ENUM(BDMA_STATUS_0, GRP0_BUSY, YES) ?
+                               1 : 0;
+       } else {
+               pointer = reg_read(map_ptr_addr[processor->op_type]);
+               hw_consumer_ptr = (pointer & MASK(CDP_S_POINTER_0, CONSUMER)) >>
+                               SHIFT(CDP_S_POINTER_0, CONSUMER);
+
+               /*
+                * Read current consumer pointer for RDMA only if processor
+                * has RDMA module
+                */
+               if (map_rdma_ptr_addr[processor->op_type] != 0xFFFFFFFF) {
+                       pointer =
+                       reg_read(map_rdma_ptr_addr[processor->op_type]);
+                       hw_rdma_ptr = (pointer &
+                                       MASK(CDP_S_POINTER_0, CONSUMER)) >>
+                                       SHIFT(CDP_S_POINTER_0, CONSUMER);
+               }
+       }
+
+       /*
+        * If both processors are programmed then exit
+        */
+       if (processor->group_status == 0x3) {
+               ret = ERR(PROCESSOR_BUSY);
+               goto exit;
+       }
+
+       if (!processor->group_status)
+               /*
+                * If both groups are idle then use consumer pointer
+                */
+               *group_id = hw_consumer_ptr;
+       else
+               /*
+                * Here it is assumed that only one group is idle or busy
+                * and hence right shift will work to get correct
+                * group id
+                */
+               *group_id = !(processor->group_status >> 1);
+
+       /*
+        * If both groups are idle then read group id from pointer
+        */
+       if (!processor->rdma_status)
+               *rdma_id = hw_rdma_ptr;
+       else
+               *rdma_id = !(processor->rdma_status >> 1);
+
+exit:
+       RETURN(ret);
+}

diff --git a/drivers/nvdla/engine_data.c b/drivers/nvdla/engine_data.c
new file mode 100644 (file)
index 0000000..c967cff
--- /dev/null
+++ b/drivers/nvdla/engine_data.c
@@ -0,0 +1,303 @@
+/*
+ * 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.
+ */
+
+#include <nvdla_interface.h>
+#include <dla_interface.h>
+
+#include "dla_engine_internal.h"
+
+static union dla_operation_container operation_desc[DLA_OP_NUM][DLA_NUM_GROUPS];
+static union dla_surface_container surface_desc[DLA_OP_NUM][DLA_NUM_GROUPS];
+
+static struct dla_task global_task;
+
+static struct dla_engine engine = {
+       .processors[DLA_OP_BDMA] = {
+               .name = "BDMA",
+               .op_type = DLA_OP_BDMA,
+               .program = dla_bdma_program,
+               .enable = dla_bdma_enable,
+               .set_producer = dla_bdma_set_producer,
+               .is_ready = dla_bdma_is_ready,
+               .dump_config = dla_bdma_dump_config,
+               .rdma_check = dla_bdma_rdma_check,
+               .get_stat_data = dla_bdma_stat_data,
+               .dump_stat = dla_bdma_dump_stat,
+               .consumer_ptr = 0,
+               .roi_index = 0,
+               .group_status = 0,
+               .rdma_status = 0,
+               .last_group = 1,
+               .groups[0] = {
+                       .id = 0,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_BDMA][0],
+                       .surface_desc = &surface_desc[DLA_OP_BDMA][0],
+               },
+               .groups[1] = {
+                       .id = 1,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_BDMA][1],
+                       .surface_desc = &surface_desc[DLA_OP_BDMA][1],
+               },
+       },
+       .processors[DLA_OP_CONV] = {
+               .name = "Convolution",
+               .op_type = DLA_OP_CONV,
+               .program = dla_conv_program,
+               .enable = dla_conv_enable,
+               .set_producer = dla_conv_set_producer,
+               .is_ready = dla_conv_is_ready,
+               .dump_config = dla_conv_dump_config,
+               .rdma_check = dla_conv_rdma_check,
+               .get_stat_data = dla_conv_stat_data,
+               .dump_stat = dla_conv_dump_stat,
+               .consumer_ptr = 0,
+               .roi_index = 0,
+               .group_status = 0,
+               .rdma_status = 0,
+               .last_group = 1,
+               .groups[0] = {
+                       .id = 0,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_CONV][0],
+                       .surface_desc = &surface_desc[DLA_OP_CONV][0],
+               },
+               .groups[1] = {
+                       .id = 1,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_CONV][1],
+                       .surface_desc = &surface_desc[DLA_OP_CONV][1],
+               },
+       },
+       .processors[DLA_OP_SDP] = {
+               .name = "SDP",
+               .op_type = DLA_OP_SDP,
+               .program = dla_sdp_program,
+               .enable = dla_sdp_enable,
+               .set_producer = dla_sdp_set_producer,
+               .is_ready = dla_sdp_is_ready,
+               .dump_config = dla_sdp_dump_config,
+               .rdma_check = dla_sdp_rdma_check,
+               .get_stat_data = dla_sdp_stat_data,
+               .dump_stat = dla_sdp_dump_stat,
+               .consumer_ptr = 0,
+               .roi_index = 0,
+               .group_status = 0,
+               .rdma_status = 0,
+               .last_group = 1,
+               .groups[0] = {
+                       .id = 0,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_SDP][0],
+                       .surface_desc = &surface_desc[DLA_OP_SDP][0],
+               },
+               .groups[1] = {
+                       .id = 1,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_SDP][1],
+                       .surface_desc = &surface_desc[DLA_OP_SDP][1],
+               },
+       },
+       .processors[DLA_OP_PDP] = {
+               .name = "PDP",
+               .op_type = DLA_OP_PDP,
+               .program = dla_pdp_program,
+               .enable = dla_pdp_enable,
+               .set_producer = dla_pdp_set_producer,
+               .is_ready = dla_pdp_is_ready,
+               .dump_config = dla_pdp_dump_config,
+               .rdma_check = dla_pdp_rdma_check,
+               .get_stat_data = dla_pdp_stat_data,
+               .dump_stat = dla_pdp_dump_stat,
+               .consumer_ptr = 0,
+               .roi_index = 0,
+               .group_status = 0,
+               .rdma_status = 0,
+               .last_group = 1,
+               .groups[0] = {
+                       .id = 0,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_PDP][0],
+                       .surface_desc = &surface_desc[DLA_OP_PDP][0],
+               },
+               .groups[1] = {
+                       .id = 1,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_PDP][1],
+                       .surface_desc = &surface_desc[DLA_OP_PDP][1],
+               },
+       },
+       .processors[DLA_OP_CDP] = {
+               .name = "CDP",
+               .op_type = DLA_OP_CDP,
+               .program = dla_cdp_program,
+               .enable = dla_cdp_enable,
+               .set_producer = dla_cdp_set_producer,
+               .is_ready = dla_cdp_is_ready,
+               .dump_config = dla_cdp_dump_config,
+               .rdma_check = dla_cdp_rdma_check,
+               .get_stat_data = dla_cdp_stat_data,
+               .dump_stat = dla_cdp_dump_stat,
+               .consumer_ptr = 0,
+               .roi_index = 0,
+               .group_status = 0,
+               .rdma_status = 0,
+               .last_group = 1,
+               .groups[0] = {
+                       .id = 0,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_CDP][0],
+                       .surface_desc = &surface_desc[DLA_OP_CDP][0],
+               },
+               .groups[1] = {
+                       .id = 1,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_CDP][1],
+                       .surface_desc = &surface_desc[DLA_OP_CDP][1],
+               },
+       },
+
+       .processors[DLA_OP_RUBIK] = {
+               .name = "RUBIK",
+               .op_type = DLA_OP_RUBIK,
+               .program = dla_rubik_program,
+               .enable = dla_rubik_enable,
+               .set_producer = dla_rubik_set_producer,
+               .is_ready = dla_rubik_is_ready,
+               .dump_config = dla_rubik_dump_config,
+               .rdma_check = dla_rubik_rdma_check,
+               .get_stat_data = dla_rubik_stat_data,
+               .dump_stat = dla_rubik_dump_stat,
+               .consumer_ptr = 0,
+               .roi_index = 0,
+               .group_status = 0,
+               .rdma_status = 0,
+               .last_group = 1,
+               .groups[0] = {
+                       .id = 0,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_RUBIK][0],
+                       .surface_desc = &surface_desc[DLA_OP_RUBIK][0],
+               },
+               .groups[1] = {
+                       .id = 1,
+                       .rdma_id = 0,
+                       .active = 0,
+                       .events = 0,
+                       .roi_index = 0,
+                       .is_rdma_needed = 0,
+                       .lut_index = -1,
+                       .operation_desc = &operation_desc[DLA_OP_RUBIK][1],
+                       .surface_desc = &surface_desc[DLA_OP_RUBIK][1],
+               },
+       },
+
+};
+
+struct dla_engine *dla_get_engine(void)
+{
+       return &engine;
+}
+
+int32_t dla_register_driver(void **engine_context, void *driver_context)
+{
+       *engine_context = &engine;
+       engine.task = &global_task;
+       engine.driver_context = driver_context;
+       engine.task->task_data = NULL;
+
+       dla_init_op_cache(&engine);
+
+       RETURN(0);
+}
+
+uint32_t reg_read(uint32_t addr)
+{
+       return dla_reg_read(engine.driver_context, addr);
+}
+
+void reg_write(uint32_t addr, uint32_t reg)
+{
+       dla_reg_write(engine.driver_context, addr, reg);
+}

diff --git a/drivers/nvdla/engine_debug.c b/drivers/nvdla/engine_debug.c
new file mode 100644 (file)
index 0000000..7ed4f0a
--- /dev/null
+++ b/drivers/nvdla/engine_debug.c
@@ -0,0 +1,551 @@
+/*
+ * 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.
+ */
+
+#include <dla_debug.h>
+#include <dla_interface.h>
+#include <dla_sched.h>
+
+#include "engine_debug.h"
+
+#if DEBUG_NETWORK_DATA
+
+void
+dla_debug_network_desc(struct dla_network_desc *nd)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW dla_network_desc\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("op desc index      = %d\n", nd->operation_desc_index);
+       dla_debug("surface desc index = %d\n", nd->surface_desc_index);
+       dla_debug("dep graph index    = %d\n", nd->dependency_graph_index);
+       dla_debug("lut data index     = %d\n", nd->lut_data_index);
+       dla_debug("stat_list_index    = %d\n", nd->stat_list_index);
+       dla_debug("roi array index    = %d\n", nd->roi_array_index);
+       dla_debug("surface index      = %d\n", nd->surface_index);
+       dla_debug("num rois           = %u\n", nd->num_rois);
+       dla_debug("num ops            = %u\n", nd->num_operations);
+       dla_debug("num luts           = %u\n", nd->num_luts);
+       dla_debug("num addr           = %u\n", nd->num_addresses);
+       dla_debug("input layer        = %u\n", nd->input_layer);
+       dla_debug("dynamic roi        = %u\n", nd->dynamic_roi);
+}
+
+static void
+dla_debug_bdma_transfer(struct dla_bdma_transfer_desc *tr, int32_t id)
+{
+       dla_debug("transfer[%d]            = [ dla_bdma_transfer_desc =>\n", id);
+       dla_debug("    source_address      = %x\n", tr->source_address);
+       dla_debug("    destination_address = %x\n", tr->destination_address);
+       dla_debug("    line_size           = %x\n", tr->line_size);
+       dla_debug("    line_repeat         = %x\n", tr->line_repeat);
+       dla_debug("    source_line         = %x\n", tr->source_line);
+       dla_debug("    destination_line    = %x\n", tr->destination_line);
+       dla_debug("    surface_repeat      = %x\n", tr->surface_repeat);
+       dla_debug("    source_surface      = %x\n", tr->source_surface);
+       dla_debug("    destination_surface = %x\n", tr->destination_surface);
+}
+
+void
+dla_debug_bdma_surface_desc(struct dla_bdma_surface_desc *desc, int32_t roi)
+{
+       int32_t i;
+
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_bdma_surface_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("source_type      = %u\n", desc->source_type);
+       dla_debug("destination_type = %u\n", desc->destination_type);
+       dla_debug("num_transfers    = %u\n", desc->num_transfers);
+       for (i = 0; i < desc->num_transfers; i++)
+               dla_debug_bdma_transfer(&desc->transfers[i], i);
+}
+
+void
+dla_debug_bdma_op_desc(struct dla_bdma_op_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_bdma_op_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("num_transfers    = %u\n", desc->num_transfers);
+}
+
+void
+dla_debug_address_info(struct dla_task *tk)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW address list\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("task base address        = %llu\n", tk->base);
+       dla_debug("op desc address          = %llu\n", tk->operation_desc_addr);
+       dla_debug("surface desc address     = %llu\n", tk->surface_desc_addr);
+       dla_debug("dependency graph address = %llu\n", tk->dependency_graph_addr);
+       dla_debug("LUT data address         = %llu\n", tk->lut_data_addr);
+       dla_debug("stat address             = %llu\n", tk->stat_data_addr);
+       dla_debug("ROI array address        = %llu\n", tk->roi_array_addr);
+       dla_debug("surface address          = %llu\n", tk->surface_addr);
+}
+
+void
+dla_debug_op_desc(struct dla_common_op_desc *desc, int32_t roi)
+{
+       int32_t i;
+
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_common_op_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("[%p] Operation index %d ROI %d dep_count %d type %d\n",
+                       (unsigned int *)desc, desc->index, desc->roi_index,
+                       desc->dependency_count, desc->op_type);
+       dla_debug("consumers = [ dla_consumer =>\n");
+       for (i = 0; i < DLA_OP_NUM; i++)
+               dla_debug(" [ %d %d ]", desc->consumers[i].index,
+                                       desc->consumers[i].event);
+       dla_debug("]");
+       dla_debug("fused_parent = [ dla_consumer =>\n");
+       dla_debug(" [ %d %d ]", desc->fused_parent.index,
+                                       desc->fused_parent.event);
+       dla_debug("]");
+}
+
+static void
+dla_debug_data_cube(struct dla_data_cube *cube)
+{
+       dla_debug("    type          = %u\n", cube->type);
+       dla_debug("    address       = %d\n", cube->address);
+       dla_debug("    width         = %x\n", cube->width);
+       dla_debug("    height        = %x\n", cube->height);
+       dla_debug("    channel       = %x\n", cube->channel);
+       dla_debug("    size          = %u\n", cube->size);
+       dla_debug("    line_stride   = %u\n", cube->line_stride);
+       dla_debug("    surf_stride   = %u\n", cube->surf_stride);
+       dla_debug("    plane_stride  = %u\n", cube->plane_stride);
+       dla_debug("]");
+}
+
+static void
+dla_debug_converter(struct dla_cvt_param *cvt)
+{
+       dla_debug("[ scale = %d, truncate = %u, enable = %u, offset = %d ]\n",
+                       cvt->scale, cvt->truncate, cvt->enable, cvt->offset);
+}
+
+static void
+dla_debug_float_data(struct dla_float_data *float_data)
+{
+       dla_debug("[ scale = %d, shifter = %d ]\n",
+                       float_data->scale, float_data->shifter);
+}
+
+static void
+dla_debug_dla_slope(union dla_slope *slope)
+{
+       dla_debug("    data_i =\n");
+       dla_debug_float_data(&slope->data_i);
+       dla_debug("    data_f = %u\n", slope->data_f);
+}
+
+static void
+dla_debug_lut_offset(union dla_lut_offset *offset)
+{
+       dla_debug("    exp_offset = %d\n", offset->exp_offset);
+       dla_debug("    frac_bits  = %d\n", offset->frac_bits);
+}
+
+void
+dla_debug_lut_params(struct dla_lut_param *lut_param)
+{
+       int32_t i, j;
+
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW dla_lut_param\n");
+       dla_debug("---------------------------------------------------------\n");
+
+       dla_debug("linear_exp_table            = [\n");
+       for (i = 0; i < (1<<LUT_LINEAR_EXP_TABLE_ENTRY_LOG2)+1; i++)
+               dla_debug(" %u", lut_param->linear_exp_table[i]);
+       dla_debug("]");
+
+       dla_debug("linear_only_table           = [\n");
+       for (j = 0; j < (1<<LUT_LINEAR_ONLY_TABLE_ENTRY_LOG2)+1; j++)
+               dla_debug(" %u\n", lut_param->linear_only_table[j]);
+       dla_debug("]\n");
+
+       dla_debug("linear_exp_offset           =\n");
+       dla_debug_lut_offset(&lut_param->linear_exp_offset);
+       dla_debug("linear_only_offset          =\n");
+       dla_debug_lut_offset(&lut_param->linear_only_offset);
+       dla_debug("linear_exp_start            = %llu\n",
+                               lut_param->linear_exp_start);
+       dla_debug("linear_exp_end            = %llu\n",
+                               lut_param->linear_exp_end);
+       dla_debug("linear_only_start           = %llu\n",
+                               lut_param->linear_only_start);
+       dla_debug("linear_only_end           = %llu\n",
+                               lut_param->linear_only_end);
+       dla_debug("linear_exp_underflow_slope  =\n");
+       dla_debug_dla_slope(&lut_param->linear_exp_underflow_slope);
+       dla_debug("linear_exp_overflow_slope   =\n");
+       dla_debug_dla_slope(&lut_param->linear_exp_overflow_slope);
+       dla_debug("linear_only_underflow_slope =\n");
+       dla_debug_dla_slope(&lut_param->linear_only_underflow_slope);
+       dla_debug("linear_only_overflow_slope  =\n");
+       dla_debug_dla_slope(&lut_param->linear_only_overflow_slope);
+       dla_debug("hybrid_priority             = %u\n",
+                               lut_param->hybrid_priority);
+       dla_debug("underflow_priority          = %u\n",
+                               lut_param->underflow_priority);
+       dla_debug("overflow_priority           = %u\n",
+                               lut_param->overflow_priority);
+       dla_debug("method                      = %u\n",
+                               lut_param->method);
+}
+
+void
+dla_debug_bdma_stats(struct dla_bdma_stat_desc *stat)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW STATS: dla_bdma_stat_desc\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("read_stall   = %u\n", stat->read_stall);
+       dla_debug("write_stall  = %u\n", stat->write_stall);
+       dla_debug("runtime      = %u\n", stat->runtime);
+}
+
+void
+dla_debug_conv_surface_desc(struct dla_conv_surface_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_conv_surface_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("weight_data         = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->weight_data);
+       dla_debug("wmb_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->wmb_data);
+       dla_debug("wgs_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->wgs_data);
+       dla_debug("src_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->src_data);
+       dla_debug("dst_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->dst_data);
+       dla_debug("offset_u            = %lld\n", desc->offset_u);
+       dla_debug("in_line_uv_stride   = %u\n", desc->in_line_uv_stride);
+}
+
+void
+dla_debug_conv_op_desc(struct dla_conv_op_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_conv_op_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("conv_mode          = %u\n", desc->conv_mode);
+       dla_debug("data_reuse         = %u\n", desc->data_reuse);
+       dla_debug("weight_reuse       = %u\n", desc->weight_reuse);
+       dla_debug("skip_data_rls      = %u\n", desc->skip_data_rls);
+       dla_debug("skip_weight_rls    = %u\n", desc->skip_weight_rls);
+       dla_debug("entry_per_slice    = %u\n", desc->entry_per_slice);
+       dla_debug("data_format        = %u\n", desc->data_format);
+       dla_debug("pixel_mapping      = %u\n", desc->pixel_mapping);
+       dla_debug("fetch_grain        = %u\n", desc->fetch_grain);
+       dla_debug("batch              = %u\n", desc->batch);
+       dla_debug("weight_format      = %u\n", desc->weight_format);
+       dla_debug("data_bank          = %u\n", desc->data_bank);
+       dla_debug("weight_bank        = %u\n", desc->weight_bank);
+       dla_debug("batch_stride       = %u\n", desc->batch_stride);
+       dla_debug("post_extension     = %u\n", desc->post_extension);
+       dla_debug("pixel_override     = %u\n", desc->pixel_override);
+       dla_debug("release            = %u\n", desc->release);
+       dla_debug("input_width_csc    = %u\n", desc->input_width_csc);
+       dla_debug("input_height_csc   = %u\n", desc->input_height_csc);
+       dla_debug("input_channel_csc  = %u\n", desc->input_channel_csc);
+       dla_debug("kernel_width_csc   = %u\n", desc->kernel_width_csc);
+       dla_debug("kernel_height_csc  = %u\n", desc->kernel_height_csc);
+       dla_debug("kernel_channel_csc = %u\n", desc->kernel_channel_csc);
+       dla_debug("input_width_cmac   = %u\n", desc->input_width_cmac);
+       dla_debug("input_height_cmac  = %u\n", desc->input_height_cmac);
+       dla_debug("bytes_per_kernel   = %u\n", desc->bytes_per_kernel);
+       dla_debug("mean_ry            = %d\n", desc->mean_ry);
+       dla_debug("mean_gu            = %d\n", desc->mean_gu);
+       dla_debug("mean_bv            = %d\n", desc->mean_bv);
+       dla_debug("mean_ax            = %d\n", desc->mean_ax);
+       dla_debug("mean_format        = %u\n", desc->mean_format);
+       dla_debug("conv_stride_x      = %u\n", desc->conv_stride_x);
+       dla_debug("conv_stride_y      = %u\n", desc->conv_stride_y);
+       dla_debug("pad_x_left         = %u\n", desc->pad_x_left);
+       dla_debug("pad_x_right        = %u\n", desc->pad_x_right);
+       dla_debug("pad_y_top          = %u\n", desc->pad_y_top);
+       dla_debug("pad_y_bottom       = %u\n", desc->pad_y_bottom);
+       dla_debug("dilation_x         = %u\n", desc->dilation_x);
+       dla_debug("dilation_y         = %u\n", desc->dilation_y);
+       dla_debug("pra_truncate       = %u\n", desc->pra_truncate);
+       dla_debug("in_precision       = %u\n", desc->in_precision);
+       dla_debug("out_precision      = %u\n", desc->out_precision);
+       dla_debug("pad_val            = %d\n", desc->pad_val);
+       dla_debug("in_cvt             =\n");
+       dla_debug_converter(&desc->in_cvt);
+       dla_debug("out_cvt            =\n");
+       dla_debug_converter(&desc->out_cvt);
+}
+
+void
+dla_debug_conv_stats(struct dla_conv_stat_desc *stat)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW STATS: dla_conv_stat_desc\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("data_read_stall      = %u\n", stat->data_read_stall);
+       dla_debug("weight_read_stall    = %u\n", stat->weight_read_stall);
+       dla_debug("data_read_latency    = %u\n", stat->data_read_latency);
+       dla_debug("weight_read_latency  = %u\n", stat->weight_read_latency);
+       dla_debug("saturation_count     = %u\n", stat->saturation_count);
+       dla_debug("nan_data_num         = %u\n", stat->nan_data_num);
+       dla_debug("nan_weight_num       = %u\n", stat->nan_weight_num);
+       dla_debug("inf_data_num         = %u\n", stat->inf_data_num);
+       dla_debug("inf_weight_num       = %u\n", stat->inf_weight_num);
+       dla_debug("runtime              = %u\n", stat->runtime);
+}
+
+void
+dla_debug_pdp_surface_desc(struct dla_pdp_surface_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_pdp_surface_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("src_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->src_data);
+       dla_debug("dst_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->dst_data);
+}
+
+void
+dla_debug_pdp_op_desc(struct dla_pdp_op_desc *desc, int32_t roi)
+{
+       int32_t i;
+
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_pdp_op_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("precision               = %u\n", desc->precision);
+       dla_debug("padding_value           = [\n");
+       for (i = 0; i < PDP_PAD_VAL_NUM; i++)
+               dla_debug(" %d\n", desc->padding_value[i]);
+       dla_debug("]\n");
+       dla_debug("split_num               = %u\n", desc->split_num);
+       dla_debug("partial_in_width_first  = %u\n",
+                                       desc->partial_in_width_first);
+       dla_debug("partial_in_width_mid    = %u\n", desc->partial_in_width_mid);
+       dla_debug("partial_in_width_last   = %u\n", desc->partial_in_width_last);
+       dla_debug("partial_width_first     = %u\n", desc->partial_width_first);
+       dla_debug("partial_width_mid       = %u\n", desc->partial_width_mid);
+       dla_debug("partial_width_last      = %u\n", desc->partial_width_last);
+       dla_debug("pool_mode               = %u\n", desc->pool_mode);
+       dla_debug("pool_width              = %u\n", desc->pool_width);
+       dla_debug("pool_height             = %u\n", desc->pool_height);
+       dla_debug("stride_x                = %u\n", desc->stride_x);
+       dla_debug("stride_y                = %u\n", desc->stride_y);
+       dla_debug("pad_left                = %u\n", desc->pad_left);
+       dla_debug("pad_right               = %u\n", desc->pad_right);
+       dla_debug("pad_top                 = %u\n", desc->pad_top);
+       dla_debug("pad_bottom              = %u\n", desc->pad_bottom);
+}
+
+void
+dla_debug_pdp_stats(struct dla_pdp_stat_desc *stat)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW STATS: dla_pdp_stat_desc\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("inf_input_num   = %u\n", stat->inf_input_num);
+       dla_debug("nan_input_num   = %u\n", stat->nan_input_num);
+       dla_debug("nan_output_num  = %u\n", stat->nan_output_num);
+       dla_debug("write_stall     = %u\n", stat->write_stall);
+       dla_debug("runtime         = %u\n", stat->runtime);
+}
+
+void
+dla_debug_cdp_surface_desc(struct dla_cdp_surface_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_cdp_surface_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("src_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->src_data);
+       dla_debug("dst_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->dst_data);
+}
+
+void
+dla_debug_cdp_op_desc(struct dla_cdp_op_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_cdp_op_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("in_precision      = %u\n", desc->in_precision);
+       dla_debug("out_precision     = %u\n", desc->out_precision);
+       dla_debug("lut_index         = %d\n", desc->lut_index);
+       dla_debug("in_cvt             =\n");
+       dla_debug_converter(&desc->in_cvt);
+       dla_debug("out_cvt             =\n");
+       dla_debug_converter(&desc->out_cvt);
+       dla_debug("local_size        = %u\n", desc->local_size);
+       dla_debug("bypass_sqsum      = %u\n", desc->bypass_sqsum);
+       dla_debug("bypass_out_mul    = %u\n", desc->bypass_out_mul);
+}
+
+void
+dla_debug_cdp_stats(struct dla_cdp_stat_desc *stat)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW STATS: dla_cdp_stat_desc\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("nan_input_num     = %u\n", stat->nan_input_num);
+       dla_debug("inf_input_num     = %u\n", stat->inf_input_num);
+       dla_debug("nan_output_num    = %u\n", stat->nan_output_num);
+       dla_debug("write_stall       = %u\n", stat->write_stall);
+       dla_debug("lut_uflow         = %u\n", stat->lut_uflow);
+       dla_debug("lut_oflow         = %u\n", stat->lut_oflow);
+       dla_debug("lut_hybrid        = %u\n", stat->lut_hybrid);
+       dla_debug("lut_le_hit        = %u\n", stat->lut_le_hit);
+       dla_debug("lut_lo_hit        = %u\n", stat->lut_lo_hit);
+       dla_debug("saturation_count  = %u\n", stat->saturation_count);
+       dla_debug("runtime           = %u\n", stat->runtime);
+}
+
+void
+dla_debug_rubik_surface_desc(struct dla_rubik_surface_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_rubik_surface_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("src_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->src_data);
+       dla_debug("dst_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->dst_data);
+}
+
+void
+dla_debug_rubik_op_desc(struct dla_rubik_op_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_rubik_op_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("mode       = %u\n", desc->mode);
+       dla_debug("precision  = %u\n", desc->precision);
+       dla_debug("stride_x   = %u\n", desc->stride_x);
+       dla_debug("stride_y   = %u\n", desc->stride_y);
+}
+
+void
+dla_debug_rubik_stats(struct dla_rubik_stat_desc *stat)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW STATS: dla_rubik_stat_desc\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("read_stall   = %u\n", stat->read_stall);
+       dla_debug("write_stall  = %u\n", stat->write_stall);
+       dla_debug("runtime      = %u\n", stat->runtime);
+}
+
+static void
+dla_debug_sdp_op(struct dla_sdp_op *sdp_op)
+{
+       dla_debug("    enable         = %u\n", sdp_op->enable);
+       dla_debug("    alu_type       = %u\n", sdp_op->alu_type);
+       dla_debug("    type           = %u\n", sdp_op->type);
+       dla_debug("    mode           = %u\n", sdp_op->mode);
+       dla_debug("    act            = %u\n", sdp_op->act);
+       dla_debug("    shift_value    = %u\n", sdp_op->shift_value);
+       dla_debug("    truncate       = %u\n", sdp_op->truncate);
+       dla_debug("    precision      = %u\n", sdp_op->precision);
+       dla_debug("    alu_operand    = %d\n", sdp_op->alu_operand);
+       dla_debug("    mul_operand    = %d\n", sdp_op->mul_operand);
+       dla_debug("cvt.alu_cvt          =\n");
+       dla_debug_converter(&sdp_op->cvt.alu_cvt);
+       dla_debug("cvt.mul_cvt          =\n");
+       dla_debug_converter(&sdp_op->cvt.mul_cvt);
+       dla_debug("]\n");
+}
+
+void
+dla_debug_sdp_surface_desc(struct dla_sdp_surface_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_sdp_surface_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("src_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->src_data);
+       dla_debug("x1_data             = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->x1_data);
+       dla_debug("x2_data             = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->x2_data);
+       dla_debug("y_data              = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->y_data);
+       dla_debug("dst_data            = [ dla_data_cube =>\n");
+       dla_debug_data_cube(&desc->dst_data);
+}
+
+void
+dla_debug_sdp_op_desc(struct dla_sdp_op_desc *desc, int32_t roi)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW ROI[%d]: dla_sdp_op_desc\n", roi);
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("src_precision    = %u\n", desc->src_precision);
+       dla_debug("dst_precision    = %u\n", desc->dst_precision);
+       dla_debug("lut_index        = %d\n", desc->lut_index);
+       dla_debug("out_cvt          =\n");
+       dla_debug_converter(&desc->out_cvt);
+       dla_debug("conv_mode        = %u\n", desc->conv_mode);
+       dla_debug("batch_num        = %u\n", desc->batch_num);
+       dla_debug("batch_stride     = %u\n", desc->batch_stride);
+       dla_debug("x1_op            = [ dla_sdp_op =>\n");
+       dla_debug_sdp_op(&desc->x1_op);
+       dla_debug("x2_op            = [ dla_sdp_op =>\n");
+       dla_debug_sdp_op(&desc->x2_op);
+       dla_debug("y_op             = [ dla_sdp_op =>\n");
+       dla_debug_sdp_op(&desc->y_op);
+}
+
+void
+dla_debug_sdp_stats(struct dla_sdp_stat_desc *stat)
+{
+       dla_debug("*********************************************************\n");
+       dla_debug("NVDLA FW STATS: dla_sdp_stat_desc\n");
+       dla_debug("---------------------------------------------------------\n");
+       dla_debug("nan_input_num     = %u\n", stat->nan_input_num);
+       dla_debug("inf_input_num     = %u\n", stat->inf_input_num);
+       dla_debug("nan_output_num    = %u\n", stat->nan_output_num);
+       dla_debug("wdma_write_stall  = %u\n", stat->wdma_write_stall);
+       dla_debug("lut_underflow     = %u\n", stat->lut_underflow);
+       dla_debug("lut_overflow      = %u\n", stat->lut_overflow);
+       dla_debug("lut_hybrid        = %u\n", stat->lut_hybrid);
+       dla_debug("lut_le_hit        = %u\n", stat->lut_le_hit);
+       dla_debug("lut_lo_hit        = %u\n", stat->lut_lo_hit);
+       dla_debug("saturation_count  = %u\n", stat->saturation_count);
+       dla_debug("runtime           = %u\n", stat->runtime);
+}
+#endif /* DEBUG_NETWORK_DATA */

diff --git a/drivers/nvdla/engine_debug.h b/drivers/nvdla/engine_debug.h
new file mode 100644 (file)
index 0000000..d953fc4
--- /dev/null
+++ b/drivers/nvdla/engine_debug.h
@@ -0,0 +1,129 @@
+/*
+ * 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_ENGINE_DEBUG_H_
+#define __FIRMWARE_ENGINE_DEBUG_H_
+
+#include <dla_debug.h>
+#include <dla_interface.h>
+
+#if DEBUG_NETWORK_DATA
+void
+dla_debug_op_desc(struct dla_common_op_desc *desc, int32_t roi);
+void
+dla_debug_network_desc(struct dla_network_desc *network_desc);
+void
+dla_debug_address_info(struct dla_task *task);
+void
+dla_debug_bdma_surface_desc(struct dla_bdma_surface_desc *desc, int32_t roi);
+void
+dla_debug_bdma_op_desc(struct dla_bdma_op_desc *desc, int32_t roi);
+void
+dla_debug_bdma_stats(struct dla_bdma_stat_desc *stat);
+void
+dla_debug_conv_surface_desc(struct dla_conv_surface_desc *desc, int32_t roi);
+void
+dla_debug_conv_op_desc(struct dla_conv_op_desc *desc, int32_t roi);
+void
+dla_debug_conv_stats(struct dla_conv_stat_desc *stat);
+void
+dla_debug_sdp_op_desc(struct dla_sdp_op_desc *desc, int32_t roi);
+void
+dla_debug_sdp_surface_desc(struct dla_sdp_surface_desc *desc, int32_t roi);
+void
+dla_debug_sdp_stats(struct dla_sdp_stat_desc *stat);
+void
+dla_debug_pdp_surface_desc(struct dla_pdp_surface_desc *desc, int32_t roi);
+void
+dla_debug_pdp_op_desc(struct dla_pdp_op_desc *desc, int32_t roi);
+void
+dla_debug_pdp_stats(struct dla_pdp_stat_desc *stat);
+void
+dla_debug_cdp_surface_desc(struct dla_cdp_surface_desc *desc, int32_t roi);
+void
+dla_debug_cdp_op_desc(struct dla_cdp_op_desc *desc, int32_t roi);
+void
+dla_debug_cdp_stats(struct dla_cdp_stat_desc *stat);
+void
+dla_debug_rubik_op_desc(struct dla_rubik_op_desc *desc, int32_t roi);
+void
+dla_debug_rubik_surface_desc(struct dla_rubik_surface_desc *desc, int32_t roi);
+void
+dla_debug_rubik_stats(struct dla_rubik_stat_desc *stat);
+void
+dla_debug_lut_params(struct dla_lut_param *lut_param);
+
+#else
+
+static inline void
+dla_debug_op_desc(struct dla_common_op_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_network_desc(struct dla_network_desc *network_desc) {}
+static inline void
+dla_debug_address_info(struct dla_task *task) {}
+static inline void
+dla_debug_bdma_surface_desc(struct dla_bdma_surface_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_bdma_op_desc(struct dla_bdma_op_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_bdma_stats(struct dla_bdma_stat_desc *stat) {}
+static inline void
+dla_debug_conv_surface_desc(struct dla_conv_surface_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_conv_op_desc(struct dla_conv_op_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_conv_stats(struct dla_conv_stat_desc *stat) {}
+static inline void
+dla_debug_sdp_op_desc(struct dla_sdp_op_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_sdp_surface_desc(struct dla_sdp_surface_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_sdp_stats(struct dla_sdp_stat_desc *stat) {}
+static inline void
+dla_debug_pdp_surface_desc(struct dla_pdp_surface_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_pdp_op_desc(struct dla_pdp_op_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_pdp_stats(struct dla_pdp_stat_desc *stat) {}
+static inline void
+dla_debug_cdp_surface_desc(struct dla_cdp_surface_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_cdp_op_desc(struct dla_cdp_op_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_cdp_stats(struct dla_cdp_stat_desc *stat) {}
+static inline void
+dla_debug_rubik_op_desc(struct dla_rubik_op_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_rubik_surface_desc(struct dla_rubik_surface_desc *desc, int32_t roi) {}
+static inline void
+dla_debug_rubik_stats(struct dla_rubik_stat_desc *stat) {}
+static inline void
+dla_debug_lut_params(struct dla_lut_param *lut_param) {}
+
+#endif /* DEBUG_NETWORK_DATA */
+#endif /* __FIRMWARE_ENGINE_DEBUG_H_ */

diff --git a/drivers/nvdla/engine_isr.c b/drivers/nvdla/engine_isr.c
new file mode 100644 (file)
index 0000000..19ae2dd
--- /dev/null
+++ b/drivers/nvdla/engine_isr.c
@@ -0,0 +1,136 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_engine.h>
+#include <dla_interface.h>
+
+#include "dla_engine_internal.h"
+
+int32_t dla_isr_handler(void *engine_data)
+{
+       uint32_t __maybe_unused mask;
+       uint32_t reg;
+       struct dla_processor *processor = NULL;
+       struct dla_processor_group *group;
+       struct dla_engine *engine = (struct dla_engine *)engine_data;
+
+       mask = glb_reg_read(S_INTR_MASK);
+       reg = glb_reg_read(S_INTR_STATUS);
+
+       dla_trace("Enter: dla_isr_handler, reg:%x, mask:%x\n", reg, mask);
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CACC_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_CONV];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CACC_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_CONV];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, SDP_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_SDP];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, SDP_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_SDP];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CDP_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_CDP];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CDP_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_CDP];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, RUBIK_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_RUBIK];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, RUBIK_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_RUBIK];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, PDP_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_PDP];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, PDP_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_PDP];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, BDMA_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_BDMA];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, BDMA_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_BDMA];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_OP_COMPLETED);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CDMA_DAT_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_CONV];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_CDMA_DT_DONE);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CDMA_DAT_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_CONV];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_CDMA_DT_DONE);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CDMA_WT_DONE_STATUS0)) {
+               processor = &engine->processors[DLA_OP_CONV];
+               group = &processor->groups[0];
+               group->events |= (1 << DLA_EVENT_CDMA_WT_DONE);
+       }
+       if (reg & MASK(GLB_S_INTR_STATUS_0, CDMA_WT_DONE_STATUS1)) {
+               processor = &engine->processors[DLA_OP_CONV];
+               group = &processor->groups[1];
+               group->events |= (1 << DLA_EVENT_CDMA_WT_DONE);
+       }
+
+       glb_reg_write(S_INTR_STATUS, reg);
+
+       mask = glb_reg_read(S_INTR_MASK);
+       reg = glb_reg_read(S_INTR_STATUS);
+
+       dla_trace("Exit: dla_isr_handler, reg:%x, mask:%x\n", reg, mask);
+       RETURN(0);
+}

diff --git a/drivers/nvdla/include/dla_debug.h b/drivers/nvdla/include/dla_debug.h
new file mode 100644 (file)
index 0000000..bef99d6
--- /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 (file)
index 0000000..707adc4
--- /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 (file)
index 0000000..d9efcd0
--- /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 (file)
index 0000000..cbf4791
--- /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 (file)
index 0000000..7ed3548
--- /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 (file)
index 0000000..7ad40b4
--- /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 (file)
index 0000000..3c8ec3a
--- /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 (file)
index 0000000..2fc543d
--- /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 (file)
index 0000000..2b4ecd3
--- /dev/null
+++ b/drivers/nvdla/include/opendla.h
@@ -0,0 +1,40 @@
+/*
+ * 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
+
+#ifdef DLA_2_CONFIG
+#include <opendla_small.h>
+#else
+#include <opendla_initial.h>
+#endif
+
+#endif

diff --git a/drivers/nvdla/include/opendla_initial.h b/drivers/nvdla/include/opendla_initial.h
new file mode 100644 (file)
index 0000000..7133543
--- /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 (file)
index 0000000..dfcb3b0
--- /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

diff --git a/drivers/nvdla/nvdla_core_callbacks.c b/drivers/nvdla/nvdla_core_callbacks.c
new file mode 100644 (file)
index 0000000..a6150ae
--- /dev/null
+++ b/drivers/nvdla/nvdla_core_callbacks.c
@@ -0,0 +1,443 @@
+/*
+ * 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.
+ */
+
+#include <linux/dma-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/irqdomain.h>
+#include <linux/math64.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_irq.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/printk.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/time.h>
+#include <linux/uaccess.h>
+
+#include <nvdla_interface.h>
+#include <nvdla_linux.h>
+#include <nvdla_ioctl.h>
+#include <opendla.h>
+
+static struct nvdla_config nvdla_config_os_initial = {
+       .atom_size = 32,
+       .bdma_enable = true,
+       .rubik_enable = true,
+       .weight_compress_support = true,
+};
+
+static struct nvdla_config nvdla_config_small = {
+       .atom_size = 8,
+       .bdma_enable = false,
+       .rubik_enable = false,
+       .weight_compress_support = false,
+};
+
+static struct nvdla_config nvdla_config_large = {
+       .atom_size = 32,
+       .bdma_enable = false,
+       .rubik_enable = false,
+       .weight_compress_support = false,
+};
+
+void __printf(1, 2) dla_debug(const char *str, ...)
+{
+       va_list args;
+       va_start(args, str);
+       vprintk(pr_fmt(str), args);
+       va_end(args);
+}
+
+void __printf(1, 2) dla_info(const char *str, ...)
+{
+       va_list args;
+       va_start(args, str);
+       vprintk(str, args);
+       va_end(args);
+}
+
+void __printf(1, 2) dla_warn(const char *str, ...)
+{
+       va_list args;
+       va_start(args, str);
+       vprintk(str, args);
+       va_end(args);
+}
+
+void __printf(1, 2) dla_error(const char *str, ...)
+{
+       va_list args;
+       va_start(args, str);
+       vprintk(str, args);
+       va_end(args);
+}
+
+void *dla_memset(void *src, int ch, uint64_t len)
+{
+       memset(src, ch, len);
+       return src;
+}
+
+void *dla_memcpy(void *dest, const void *src, uint64_t len)
+{
+       return memcpy(dest, src, len);
+}
+
+int64_t dla_get_time_us(void)
+{
+       return div_u64(ktime_get_ns(), NSEC_PER_USEC);
+}
+
+void dla_reg_write(void *driver_context, uint32_t addr, uint32_t reg)
+{
+       struct nvdla_device *nvdla_dev =
+                       (struct nvdla_device *)driver_context;
+
+       if (!nvdla_dev)
+               return;
+
+       writel(reg, nvdla_dev->base + addr);
+}
+
+uint32_t dla_reg_read(void *driver_context, uint32_t addr)
+{
+       struct nvdla_device *nvdla_dev =
+                       (struct nvdla_device *)driver_context;
+
+       if (!nvdla_dev)
+               return 0;
+
+       return readl(nvdla_dev->base + addr);
+}
+
+static irqreturn_t nvdla_engine_isr(int32_t irq, void *data)
+{
+       unsigned long flags;
+       struct nvdla_device *nvdla_dev = (struct nvdla_device *)data;
+
+       if (!nvdla_dev)
+               return IRQ_NONE;
+
+       spin_lock_irqsave(&nvdla_dev->nvdla_lock, flags);
+       dla_isr_handler(nvdla_dev->engine_context);
+       complete(&nvdla_dev->event_notifier);
+       spin_unlock_irqrestore(&nvdla_dev->nvdla_lock, flags);
+
+       return IRQ_HANDLED;
+}
+
+static int32_t dla_read_dma_address(void *driver_context, void *task_data,
+                                               int16_t index, void *dst)
+{
+       int32_t ret = 0;
+       struct nvdla_mem_handle *handles;
+       dma_addr_t *phys_addr = (dma_addr_t *)(dst);
+       struct nvdla_device *nvdla_dev =
+                       (struct nvdla_device *)driver_context;
+       struct nvdla_task *task = (struct nvdla_task *)task_data;
+
+       if (index == -1 || index > task->num_addresses)
+               return -EINVAL;
+
+       handles = (struct nvdla_mem_handle *)task->address_list;
+       ret = nvdla_gem_dma_addr(nvdla_dev->drm, task->file,
+                                       handles[index].handle,
+                                       phys_addr);
+
+       /* Add offset to IOVA address */
+       *phys_addr = *phys_addr + handles[index].offset;
+
+       return ret;
+}
+
+static int32_t dla_read_cpu_address(void *driver_context, void *task_data,
+                                               int16_t index, void *dst)
+{
+       uint64_t *temp = (uint64_t *)dst;
+       struct nvdla_task *task = (struct nvdla_task *)task_data;
+
+       if (index == -1 || index > task->num_addresses)
+               return -EINVAL;
+
+       *temp = (uint64_t)index;
+       return 0;
+}
+
+int32_t dla_get_dma_address(void *driver_context, void *task_data,
+                                       int16_t index, void *dst_ptr,
+                                       uint32_t destination)
+{
+       int32_t ret = 0;
+
+       if (destination == DESTINATION_PROCESSOR) {
+               ret = dla_read_cpu_address(driver_context, task_data,
+                                               index, dst_ptr);
+       } else if (destination == DESTINATION_DMA) {
+               ret = dla_read_dma_address(driver_context, task_data,
+                                               index, dst_ptr);
+       } else {
+               ret = -EINVAL;
+       }
+
+       return ret;
+}
+
+int32_t dla_data_write(void *driver_context, void *task_data,
+                               void *src, uint64_t dst,
+                               uint32_t size, uint64_t offset)
+{
+       int32_t ret;
+       void *ptr = NULL;
+       struct dma_buf *buf;
+       struct iosys_map map;
+       struct nvdla_mem_handle *handles;
+       struct nvdla_task *task = (struct nvdla_task *)task_data;
+       uint64_t dma_addr = 0;
+
+       dla_get_dma_address(driver_context, task_data,dst, (void *)&dma_addr, DESTINATION_DMA);
+       handles = task->address_list;
+       buf = dma_buf_get(handles[dst].handle);
+       if (IS_ERR(buf)) {
+               pr_err("%s: Failed get dma_buf for handle=%d\n", __func__,
+                                               handles[dst].handle);
+               return -EFAULT;
+       }
+
+       ret = dma_buf_begin_cpu_access(buf, DMA_BIDIRECTIONAL);
+       if (ret)
+               goto put_dma_buf;
+
+       ret = dma_buf_vmap(buf, &map);
+       ptr = ret ? NULL : map.vaddr;
+       if (!ptr) {
+               pr_err("%s: Failed to vmap dma_buf for handle=%d\n", __func__,
+                                               handles[dst].handle);
+               ret = -ENOMEM;
+               goto end_cpu_access;
+       }
+
+       memcpy((void *)((uint8_t *)ptr + offset), src, size);
+       dma_buf_vunmap(buf, &map);
+
+end_cpu_access:
+       dma_buf_end_cpu_access(buf, DMA_BIDIRECTIONAL);
+
+put_dma_buf:
+       dma_buf_put(buf);
+
+       return ret;
+}
+
+int32_t dla_data_read(void *driver_context, void *task_data,
+                               uint64_t src, void *dst,
+                               uint32_t size, uint64_t offset)
+{
+       int32_t ret;
+       void *ptr = NULL;
+       struct dma_buf *buf;
+       struct iosys_map map;
+       struct nvdla_mem_handle *handles;
+       struct nvdla_task *task = (struct nvdla_task *)task_data;
+       uint64_t dma_addr = 0;
+
+       dla_get_dma_address(driver_context, task_data, src, (void *)&dma_addr, DESTINATION_DMA);
+       handles = task->address_list;
+
+       buf = dma_buf_get(handles[src].handle);
+       if (IS_ERR(buf)) {
+               pr_err("%s: Failed get dma_buf for handle=%d\n", __func__,
+                                               handles[src].handle);
+               return -EFAULT;
+       }
+
+       ret = dma_buf_begin_cpu_access(buf, DMA_BIDIRECTIONAL);
+       if (ret)
+               goto put_dma_buf;
+
+       ret = dma_buf_vmap(buf, &map);
+       ptr = ret ? NULL : map.vaddr;
+       if (!ptr) {
+               pr_err("%s: Failed to vmap dma_buf for handle=%d\n", __func__,
+                                               handles[src].handle);
+               ret = -ENOMEM;
+               goto end_cpu_access;
+       }
+
+       memcpy(dst, (void *)(((uint8_t *)ptr) + offset), size);
+       dma_buf_vunmap(buf, &map);
+
+end_cpu_access:
+       dma_buf_end_cpu_access(buf, DMA_BIDIRECTIONAL);
+
+put_dma_buf:
+       dma_buf_put(buf);
+
+       return ret;
+}
+
+int32_t nvdla_task_submit(struct nvdla_device *nvdla_dev, struct nvdla_task *task)
+{
+       int32_t err = 0;
+       uint32_t task_complete = 0;
+
+       nvdla_dev->task = task;
+
+       err = dla_execute_task(nvdla_dev->engine_context, (void *)task, nvdla_dev->config_data);
+       if (err) {
+               pr_err("Task execution failed\n");
+               return err;
+       }
+
+       pr_debug("Wait for task complete\n");
+
+       while (1) {
+               unsigned long flags;
+
+               wait_for_completion(&nvdla_dev->event_notifier);
+
+               spin_lock_irqsave(&nvdla_dev->nvdla_lock, flags);
+
+               err = dla_process_events(nvdla_dev->engine_context, &task_complete);
+
+               spin_unlock_irqrestore(&nvdla_dev->nvdla_lock, flags);
+
+               if (err || task_complete)
+                       break;
+       }
+
+       pr_debug("Task complete\n");
+       dla_clear_task(nvdla_dev->engine_context);
+
+       return err;
+}
+
+/* driver probe and init */
+static const struct of_device_id nvdla_of_match[] = {
+       {
+               .compatible = "nvidia,nvdla_os_initial",
+               .data = &nvdla_config_os_initial,
+       },
+       {
+               .compatible = "nvidia,nv_small",
+               .data = &nvdla_config_small,
+       },
+       {
+               .compatible = "nvidia,nv_large",
+               .data = &nvdla_config_large,
+       },
+       { },
+};
+
+static int nvdla_probe(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct nvdla_device *nvdla_dev;
+       const struct of_device_id *match;
+       int err;
+
+       if (!pdev->dev.of_node)
+               return -EINVAL;
+
+       match = of_match_device(nvdla_of_match, &pdev->dev);
+       if (!match) {
+               pr_err("Missing DT entry!\n");
+               return -EINVAL;
+       }
+
+       pr_err("Probe NVDLA config %s\n", match->compatible);
+
+       nvdla_dev = devm_kzalloc(dev, sizeof(*nvdla_dev), GFP_KERNEL);
+       if (!nvdla_dev)
+               return -ENOMEM;
+
+       platform_set_drvdata(pdev, nvdla_dev);
+       nvdla_dev->pdev = pdev;
+       nvdla_dev->config_data = (struct nvdla_config *)match->data;
+
+       init_completion(&nvdla_dev->event_notifier);
+
+       nvdla_dev->base = devm_platform_ioremap_resource(pdev, 0);
+       if (IS_ERR(nvdla_dev->base))
+               return PTR_ERR(nvdla_dev->base);
+
+       nvdla_dev->irq = platform_get_irq(pdev, 0);
+       if (nvdla_dev->irq < 0)
+               return nvdla_dev->irq;
+
+       err = devm_request_irq(&pdev->dev, nvdla_dev->irq,
+                               nvdla_engine_isr, 0,
+                               dev_name(&pdev->dev), nvdla_dev);
+       if (err)
+               return err;
+
+       dla_register_driver(&nvdla_dev->engine_context, (void *)nvdla_dev);
+       dla_clear_task(nvdla_dev->engine_context);
+
+       err = nvdla_drm_probe(nvdla_dev);
+       if (err)
+               dev_err(&pdev->dev, "failed to register drm device\n");
+
+       return err;
+}
+
+static int __exit nvdla_remove(struct platform_device *pdev)
+{
+       struct nvdla_device *nvdla_dev = dev_get_drvdata(&pdev->dev);
+
+       nvdla_drm_remove(nvdla_dev);
+
+       return 0;
+}
+
+static struct platform_driver nvdla_driver = {
+       .probe = nvdla_probe,
+       .remove = __exit_p(nvdla_remove),
+       .driver = {
+               .name = "NVDLA",
+               .of_match_table = of_match_ptr(nvdla_of_match),
+       },
+};
+module_platform_driver(nvdla_driver);
+
+MODULE_LICENSE("Dual BSD/GPL");
+MODULE_AUTHOR("NVIDIA");
+MODULE_DESCRIPTION("Nvidia Deep Learning Accelerator driver");
+
+MODULE_IMPORT_NS(DMA_BUF);

diff --git a/drivers/nvdla/nvdla_gem.c b/drivers/nvdla/nvdla_gem.c
new file mode 100644 (file)
index 0000000..25b69ba
--- /dev/null
+++ b/drivers/nvdla/nvdla_gem.c
@@ -0,0 +1,475 @@
+/*
+ * 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.
+ */
+
+#include <drm/drm_device.h>
+#include <drm/drm_drv.h>
+#include <drm/drm_gem.h>
+#include <drm/drm_gem_dma_helper.h>
+
+#include <linux/dma-buf.h>
+#include <linux/dma-mapping.h>
+#include <linux/dma-map-ops.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+
+#include <nvdla_linux.h>
+#include <nvdla_ioctl.h>
+#include <opendla.h>
+#define to_nvdla_obj(x) container_of(x, struct nvdla_gem_object, object)
+
+struct nvdla_gem_object {
+       struct drm_gem_object object;
+
+       void *kvaddr;
+       dma_addr_t dma_addr;
+       unsigned long dma_attrs;
+};
+
+static int32_t nvdla_fill_task_desc(struct nvdla_ioctl_submit_task *local_task,
+                               struct nvdla_task *task)
+{
+       struct nvdla_mem_handle *handles;
+
+       /* update task desc fields */
+       task->num_addresses = local_task->num_addresses;
+
+       handles = kzalloc(local_task->num_addresses *
+                               sizeof(struct nvdla_mem_handle), GFP_KERNEL);
+       if (handles == NULL)
+               return -EFAULT;
+
+       /* get user addresses list */
+       if (copy_from_user(handles,
+               (void __user *)(unsigned long)local_task->address_list,
+               (task->num_addresses *
+                       sizeof(struct nvdla_mem_handle)))) {
+               pr_err("failed to copy address list from user ptr\n");
+               kfree(handles);
+               return -EFAULT;
+       }
+
+       task->address_list = handles;
+       return 0;
+}
+
+static int32_t nvdla_submit(struct drm_device *drm, void *arg,
+                                       struct drm_file *file)
+{
+       int32_t err = 0;
+       struct nvdla_task *task;
+       struct nvdla_ioctl_submit_task local_task;
+       struct nvdla_ioctl_submit_task __user *user_task;
+       struct nvdla_device *nvdla_dev = dev_get_drvdata(drm->dev);
+       struct nvdla_submit_args *args =
+                       (struct nvdla_submit_args *)arg;
+
+       user_task = (struct nvdla_ioctl_submit_task __user *)
+                       (uintptr_t)args->tasks;
+       if (!user_task)
+               return -EINVAL;
+
+       /* IOCTL copy descriptors */
+       if (copy_from_user(&local_task, (void __user *)user_task,
+                       (sizeof(*user_task))))
+               return -EFAULT;
+
+       task = kzalloc(sizeof(*task), GFP_KERNEL);
+       if (task == NULL)
+               return -EFAULT;
+
+       nvdla_dev->task = task;
+       kref_init(&task->ref);
+       task->nvdla_dev = nvdla_dev;
+       task->file = file;
+
+       /* update task desc fields */
+       err = nvdla_fill_task_desc(&local_task, task);
+       if (err)
+               goto free_task_desc;
+
+       err = nvdla_task_submit(nvdla_dev, task);
+
+       kfree(task->address_list);
+
+free_task_desc:
+       kfree(task);
+       return err;
+}
+
+static int32_t nvdla_gem_alloc(struct nvdla_gem_object *nobj)
+{
+       struct drm_gem_object *dobj = &nobj->object;
+       struct drm_device *drm = dobj->dev;
+
+       nobj->dma_attrs = DMA_ATTR_WRITE_COMBINE;
+
+       nobj->kvaddr = dma_alloc_attrs(drm->dev, dobj->size, &nobj->dma_addr,
+                                               GFP_KERNEL, nobj->dma_attrs);
+
+       if (!nobj->kvaddr)
+               return -ENOMEM;
+
+       return 0;
+}
+
+static void nvdla_gem_free(struct nvdla_gem_object *nobj)
+{
+       struct drm_gem_object *dobj = &nobj->object;
+       struct drm_device *drm = dobj->dev;
+
+       dma_free_attrs(drm->dev, dobj->size, nobj->kvaddr, nobj->dma_addr,
+                               nobj->dma_attrs);
+}
+
+static void nvdla_gem_free_object(struct drm_gem_object *dobj)
+{
+       struct nvdla_gem_object *nobj;
+
+       drm_gem_free_mmap_offset(dobj);
+
+       nobj = to_nvdla_obj(dobj);
+
+       nvdla_gem_free(nobj);
+
+       kfree(nobj);
+}
+
+static struct sg_table
+*nvdla_drm_gem_prime_get_sg_table(struct drm_gem_object *dobj)
+{
+       int32_t ret;
+       struct sg_table *sgt;
+       struct drm_device *drm = dobj->dev;
+       struct nvdla_gem_object *nobj = to_nvdla_obj(dobj);
+
+       sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
+       if (!sgt)
+               return ERR_PTR(-ENOMEM);
+
+       ret = dma_get_sgtable_attrs(drm->dev, sgt, nobj->kvaddr,
+                       nobj->dma_addr, dobj->size,
+                       nobj->dma_attrs);
+       if (ret) {
+               DRM_ERROR("failed to allocate sgt, %d\n", ret);
+               kfree(sgt);
+               return ERR_PTR(ret);
+       }
+
+       return sgt;
+}
+
+static int nvdla_drm_gem_prime_vmap(struct drm_gem_object *obj, struct iosys_map *map)
+{
+       struct nvdla_gem_object *nobj = to_nvdla_obj(obj);
+       if (nobj->dma_attrs & DMA_ATTR_NO_KERNEL_MAPPING)
+               return -ENOMEM;
+       iosys_map_set_vaddr(map, nobj->kvaddr);
+       return 0;
+}
+
+static void nvdla_drm_gem_prime_vunmap(struct drm_gem_object *obj, struct iosys_map *map)
+{
+    /* Nothing to do */
+}
+
+static const struct drm_gem_object_funcs nvdla_gem_funcs = {
+       .free                   = nvdla_gem_free_object,
+       .export                 = drm_gem_prime_export,
+       .vmap                   = nvdla_drm_gem_prime_vmap,
+       .vunmap                 = nvdla_drm_gem_prime_vunmap,
+       .get_sg_table   = nvdla_drm_gem_prime_get_sg_table,
+       .vm_ops                 = &drm_gem_dma_vm_ops,
+};
+
+static struct nvdla_gem_object *
+nvdla_gem_create_object(struct drm_device *drm, uint32_t size)
+{
+       int32_t ret;
+       struct drm_gem_object *dobj;
+       struct nvdla_gem_object *nobj;
+
+       size = round_up(size, PAGE_SIZE);
+
+       nobj = kzalloc(sizeof(*nobj), GFP_KERNEL);
+       if (!nobj)
+               return ERR_PTR(-ENOMEM);
+
+       dobj = &nobj->object;
+       dobj->funcs = &nvdla_gem_funcs;
+
+       drm_gem_private_object_init(drm, dobj, size);
+
+       ret = nvdla_gem_alloc(nobj);
+       if (ret)
+               goto free_nvdla_obj;
+
+       return nobj;
+
+free_nvdla_obj:
+       kfree(nobj);
+       return ERR_PTR(ret);
+}
+
+static struct nvdla_gem_object *
+nvdla_gem_create_with_handle(struct drm_file *file_priv,
+                               struct drm_device *drm, uint32_t size,
+                               uint32_t *handle)
+{
+       int32_t ret;
+       struct drm_gem_object *dobj;
+       struct nvdla_gem_object *nobj;
+
+       nobj = nvdla_gem_create_object(drm, size);
+       if (IS_ERR(nobj))
+               return ERR_CAST(nobj);
+
+       dobj = &nobj->object;
+
+       ret = drm_gem_handle_create(file_priv, dobj, handle);
+       if (ret)
+               goto free_drm_object;
+
+       drm_gem_object_put(dobj);
+
+       return nobj;
+
+free_drm_object:
+       nvdla_gem_free_object(dobj);
+
+       return ERR_PTR(ret);
+}
+
+static int32_t nvdla_gem_create(struct drm_device *drm, void *data,
+                               struct drm_file *file)
+{
+       struct nvdla_gem_object *nobj;
+       struct nvdla_gem_create_args *args = data;
+
+       nobj = nvdla_gem_create_with_handle(file, drm, args->size,
+                                        &args->handle);
+       if (IS_ERR(nobj))
+               return PTR_ERR(nobj);
+
+       return 0;
+}
+
+static int32_t nvdla_drm_gem_object_mmap(struct drm_gem_object *dobj,
+                                       struct vm_area_struct *vma)
+{
+       int32_t ret;
+       struct nvdla_gem_object *nobj = to_nvdla_obj(dobj);
+       struct drm_device *drm = dobj->dev;
+
+       vma->vm_flags &= ~VM_PFNMAP;
+       vma->vm_pgoff = 0;
+
+       ret = dma_mmap_attrs(drm->dev, vma, nobj->kvaddr, nobj->dma_addr,
+                            dobj->size, nobj->dma_attrs);
+       if (ret)
+               drm_gem_vm_close(vma);
+
+       return ret;
+}
+
+static int32_t nvdla_drm_gem_mmap_buf(struct drm_gem_object *obj,
+                               struct vm_area_struct *vma)
+{
+       int32_t ret;
+
+       ret = drm_gem_mmap_obj(obj, obj->size, vma);
+       if (ret)
+               return ret;
+
+       return nvdla_drm_gem_object_mmap(obj, vma);
+}
+
+static int32_t nvdla_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+       int32_t ret;
+       struct drm_gem_object *obj;
+
+       ret = drm_gem_mmap(filp, vma);
+       if (ret)
+               return ret;
+
+       obj = vma->vm_private_data;
+
+       return nvdla_drm_gem_object_mmap(obj, vma);
+}
+
+int32_t nvdla_gem_dma_addr(struct drm_device *dev, struct drm_file *file,
+                       uint32_t fd, dma_addr_t *addr)
+{
+       int32_t ret;
+       uint32_t handle;
+       struct nvdla_gem_object *nobj;
+       struct drm_gem_object *dobj;
+
+       ret = drm_gem_prime_fd_to_handle(dev, file, fd, &handle);
+       if (ret)
+               return ret;
+
+       dobj = drm_gem_object_lookup(file, handle);
+       if (!dobj)
+               return -EINVAL;
+
+       nobj = to_nvdla_obj(dobj);
+
+       *addr = nobj->dma_addr;
+
+       drm_gem_object_put(dobj);
+
+       return 0;
+}
+
+static int32_t nvdla_gem_map_offset(struct drm_device *drm, void *data,
+                               struct drm_file *file)
+{
+       int32_t ret;
+       struct drm_gem_object *dobj;
+       struct nvdla_gem_map_offset_args *args = data;
+
+       dobj = drm_gem_object_lookup(file, args->handle);
+       if (!dobj)
+               return -EINVAL;
+
+       ret = drm_gem_create_mmap_offset(dobj);
+       if (ret)
+               goto out;
+
+       args->offset = drm_vma_node_offset_addr(&dobj->vma_node);
+
+out:
+       drm_gem_object_put(dobj);
+
+       return 0;
+}
+
+static int32_t nvdla_gem_destroy(struct drm_device *drm, void *data,
+                               struct drm_file *file)
+{
+       struct nvdla_gem_destroy_args *args = data;
+
+       return drm_gem_handle_delete(file, args->handle);
+}
+
+static const struct file_operations nvdla_drm_fops = {
+       .owner = THIS_MODULE,
+       .open = drm_open,
+       .release = drm_release,
+       .unlocked_ioctl = drm_ioctl,
+       .mmap = nvdla_drm_gem_mmap,
+       .poll = drm_poll,
+       .read = drm_read,
+#ifdef CONFIG_COMPAT
+       .compat_ioctl = drm_compat_ioctl,
+#endif
+       .llseek = noop_llseek,
+};
+
+static const struct drm_ioctl_desc nvdla_drm_ioctls[] = {
+       DRM_IOCTL_DEF_DRV(NVDLA_SUBMIT, nvdla_submit, DRM_RENDER_ALLOW),
+       DRM_IOCTL_DEF_DRV(NVDLA_GEM_CREATE, nvdla_gem_create, DRM_RENDER_ALLOW),
+       DRM_IOCTL_DEF_DRV(NVDLA_GEM_MMAP, nvdla_gem_map_offset, DRM_RENDER_ALLOW),
+       DRM_IOCTL_DEF_DRV(NVDLA_GEM_DESTROY, nvdla_gem_destroy, DRM_RENDER_ALLOW),
+};
+
+static struct drm_driver nvdla_drm_driver = {
+       .driver_features = DRIVER_GEM | DRIVER_RENDER,
+
+       .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
+       .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
+       .gem_prime_import = drm_gem_prime_import,
+       .gem_prime_mmap         = nvdla_drm_gem_mmap_buf,
+
+       .ioctls = nvdla_drm_ioctls,
+       .num_ioctls = ARRAY_SIZE(nvdla_drm_ioctls),
+       .fops = &nvdla_drm_fops,
+
+       .name = "nvdla",
+       .desc = "NVDLA driver",
+       .date = "20171017",
+       .major = 0,
+       .minor = 0,
+       .patchlevel = 0,
+};
+
+int32_t nvdla_drm_probe(struct nvdla_device *nvdla_dev)
+{
+       int32_t err;
+       struct drm_device *drm;
+       struct drm_driver *driver = &nvdla_drm_driver;
+       struct resource res_cma;
+       struct device_node *node;
+
+       drm = drm_dev_alloc(driver, &nvdla_dev->pdev->dev);
+       if (IS_ERR(drm))
+               return PTR_ERR(drm);
+
+       nvdla_dev->drm = drm;
+
+       err = drm_dev_register(drm, 0);
+       if (err < 0)
+               goto unref;
+
+       /**
+        * TODO Register separate driver for memory and use DT node to
+        * read memory range
+        */
+       node = of_parse_phandle(drm->dev->of_node, "memory-region", 0);
+       if(node ){
+               dev_info(drm->dev, "Get mem from memory-region\n");
+               of_address_to_resource(node, 0, &res_cma);
+               err = dma_declare_coherent_memory(drm->dev, res_cma.start, res_cma.start,resource_size(&res_cma));
+       } else {
+               dev_info(drm->dev, "NVDLA using the default mem.\n");
+               err = dma_declare_coherent_memory(drm->dev, 0xC0000000, 0xC0000000, 0x40000000);
+       }
+
+       if (err < 0) {
+               goto unref;
+       }
+
+       return 0;
+
+unref:
+       drm_dev_put(drm);
+       return err;
+}
+
+void nvdla_drm_remove(struct nvdla_device *nvdla_dev)
+{
+       drm_dev_unregister(nvdla_dev->drm);
+       drm_dev_put(nvdla_dev->drm);
+}

diff --git a/drivers/nvdla/pdp.c b/drivers/nvdla/pdp.c
new file mode 100644 (file)
index 0000000..fc98fd7
--- /dev/null
+++ b/drivers/nvdla/pdp.c
@@ -0,0 +1,528 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "common.h"
+#include "dla_engine_internal.h"
+#include "engine_debug.h"
+
+#define MAX_SPLIT_NUM  64
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a)  (sizeof(a) / sizeof((a[0])))
+#endif
+
+static const uint8_t map_ram[] = {
+       FIELD_ENUM(PDP_RDMA_D_SRC_RAM_CFG_0, SRC_RAM_TYPE, MC),
+       FIELD_ENUM(PDP_RDMA_D_SRC_RAM_CFG_0, SRC_RAM_TYPE, CV),
+};
+
+static const uint8_t map_pool[] = {
+       FIELD_ENUM(PDP_D_OPERATION_MODE_CFG_0,
+                       POOLING_METHOD, POOLING_METHOD_AVERAGE),
+       FIELD_ENUM(PDP_D_OPERATION_MODE_CFG_0,
+                       POOLING_METHOD, POOLING_METHOD_MAX),
+       FIELD_ENUM(PDP_D_OPERATION_MODE_CFG_0,
+                       POOLING_METHOD, POOLING_METHOD_MIN),
+};
+
+static const uint8_t map_precision[] = {
+       FIELD_ENUM(PDP_D_DATA_FORMAT_0, INPUT_DATA, INT8),
+       FIELD_ENUM(PDP_D_DATA_FORMAT_0, INPUT_DATA, INT16),
+       FIELD_ENUM(PDP_D_DATA_FORMAT_0, INPUT_DATA, FP16),
+};
+
+static const uint8_t map_pool_kernel[] = {
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_1),
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_2),
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_3),
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_4),
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_5),
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_6),
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_7),
+       FIELD_ENUM(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH, KERNEL_WIDTH_8),
+};
+
+/* The reciprocal of kernel width: 1/1, 1/2, 1/3, ... */
+static const uint32_t recip_kernel_size[2][8] = {
+       /*
+        * INT8/16
+        * 1      1/2     1/3     1/4     1/5     1/6     1/7     1/8
+        */
+       {0x10000, 0x8000, 0x5555, 0x4000, 0x3333, 0x2aaa, 0x2492, 0x2000},
+       {0x7c00, 0x7800, 0x7555,  0x7400, 0x7266, 0x7155, 0x7092, 0x7000},
+};
+
+#if STAT_ENABLE
+void
+dla_pdp_stat_data(struct dla_processor *processor,
+                                       struct dla_processor_group *group)
+{
+       uint64_t end_time = 0;
+       struct dla_pdp_stat_desc *pdp_stat;
+
+       pdp_stat = &processor->stat_data_desc->pdp_stat;
+
+       end_time = dla_get_time_us();
+
+       pdp_stat->write_stall = pdp_reg_read(D_PERF_WRITE_STALL);
+       pdp_stat->runtime = (uint32_t)(end_time - group->start_time);
+}
+
+void
+dla_pdp_dump_stat(struct dla_processor *processor)
+{
+       struct dla_pdp_stat_desc *pdp_stat;
+
+       pdp_stat = &processor->stat_data_desc->pdp_stat;
+
+       dla_debug_pdp_stats(pdp_stat);
+}
+#endif /* STAT_ENABLE */
+
+static uint32_t
+get_fly_mode(uint8_t type)
+{
+       uint32_t val;
+
+       val = type == DLA_MEM_HW ?
+                       FIELD_ENUM(PDP_D_OPERATION_MODE_CFG_0,
+                                               FLYING_MODE, ON_FLYING) :
+                       FIELD_ENUM(PDP_D_OPERATION_MODE_CFG_0,
+                                               FLYING_MODE, OFF_FLYING);
+
+       return val;
+}
+
+void
+dla_pdp_set_producer(int32_t group_id, int32_t rdma_group_id)
+{
+       uint32_t reg;
+
+       dla_trace("Enter: %s", __func__);
+
+       dla_debug("group id %d rdma id %d\n", group_id, rdma_group_id);
+
+       reg = group_id << SHIFT(PDP_S_POINTER_0, PRODUCER);
+       pdp_reg_write(S_POINTER, reg);
+
+       reg = rdma_group_id << SHIFT(PDP_RDMA_S_POINTER_0, PRODUCER);
+       pdp_rdma_reg_write(S_POINTER, reg);
+
+       dla_trace("Exit: %s", __func__);
+}
+
+int
+dla_pdp_enable(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       uint32_t reg;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_trace("Enter: %s", __func__);
+
+       if (!group) {
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if (engine->stat_enable == (uint32_t)1) {
+               reg = FIELD_ENUM(PDP_D_PERF_ENABLE_0, DMA_EN, ENABLE);
+               pdp_reg_write(D_PERF_ENABLE, reg);
+               group->start_time = dla_get_time_us();
+       }
+
+       dla_debug("rdma needed %u\n", group->is_rdma_needed);
+
+       /**
+        * enable all sub-modules
+        */
+       if (group->is_rdma_needed) {
+               reg = FIELD_ENUM(PDP_RDMA_D_OP_ENABLE_0, OP_EN, ENABLE);
+               pdp_rdma_reg_write(D_OP_ENABLE, reg);
+       }
+       reg = FIELD_ENUM(PDP_D_OP_ENABLE_0, OP_EN, ENABLE);
+       pdp_reg_write(D_OP_ENABLE, reg);
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+void
+dla_pdp_rdma_check(struct dla_processor_group *group)
+{
+       struct dla_pdp_surface_desc *pdp_surface;
+
+       pdp_surface = &group->surface_desc->pdp_surface;
+
+       group->is_rdma_needed = 0;
+
+       if (pdp_surface->src_data.type != DLA_MEM_HW)
+               group->is_rdma_needed = 1;
+}
+
+static int
+validate_strides(uint8_t stride_x, uint8_t stride_y)
+{
+       int32_t ret = 0;
+
+       if (stride_x < 1 || stride_y < 1 || stride_x > 8 || stride_y > 8) {
+               dla_error("Invalid Stride (x[%d], y[%d])\n", stride_x, stride_y);
+               ret = ERR(INVALID_INPUT);
+       }
+
+       RETURN(ret);
+}
+
+static int
+vaildate_pdp_configs(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       struct dla_pdp_op_desc *pdp_op;
+       struct dla_pdp_surface_desc *pdp_surface;
+
+       dla_trace("Enter: %s", __func__);
+
+       pdp_op = &group->operation_desc->pdp_op;
+       pdp_surface = &group->surface_desc->pdp_surface;
+
+       if (pdp_surface->dst_data.type == DLA_MEM_HW) {
+               dla_error("Destination buffer for PDP has to be either MC or CV");
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       ret = validate_data_cube(pdp_surface->src_data, pdp_surface->dst_data,
+                                                               DLA_MEM_HW);
+       if (ret)
+               goto exit;
+
+       ret = validate_precision(pdp_op->precision, ARRAY_SIZE(map_precision));
+       if (ret)
+               goto exit;
+
+       ret = validate_strides(pdp_op->stride_x, pdp_op->stride_y);
+       if (ret)
+               goto exit;
+
+       if (pdp_op->split_num > MAX_SPLIT_NUM) {
+               dla_error("Invalid split_num: %u\n", pdp_op->split_num);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if (pdp_op->pool_width >= ARRAY_SIZE(map_pool_kernel)) {
+               dla_error("Invalid pool_width: %u\n", pdp_op->pool_width);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if (pdp_op->pool_height >= ARRAY_SIZE(map_pool_kernel)) {
+               dla_error("Invalid pool_height: %u\n", pdp_op->pool_height);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       if (pdp_op->pool_mode >= ARRAY_SIZE(map_pool)) {
+               dla_error("Invalid pool_mode: %u\n", pdp_op->pool_mode);
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+static int
+processor_pdp_program(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       uint32_t reg, high, low;
+       uint64_t input_address = 0;
+       uint64_t output_address = 0;
+       struct dla_engine *engine = dla_get_engine();
+       struct dla_pdp_op_desc *pdp_op;
+       struct dla_pdp_surface_desc *pdp_surface;
+
+       dla_trace("Enter: %s", __func__);
+
+       pdp_op = &group->operation_desc->pdp_op;
+       pdp_surface = &group->surface_desc->pdp_surface;
+
+       ret = vaildate_pdp_configs(group);
+       if (ret)
+               goto exit;
+
+       ret = dla_read_input_address(&pdp_surface->src_data,
+                                       &input_address,
+                                       group->op_desc->index,
+                                       group->roi_index,
+                                       1);
+       if (ret)
+               goto exit;
+
+       if (pdp_surface->dst_data.address != -1)
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       pdp_surface->dst_data.address,
+                                       pdp_surface->dst_data.offset,
+                                       (void *)&output_address,
+                                       DESTINATION_DMA);
+
+       if (pdp_surface->src_data.type != DLA_MEM_HW) {
+               /* PDP RDMA */
+               pdp_rdma_reg_write(D_DATA_CUBE_IN_WIDTH,
+                               pdp_surface->src_data.width - 1);
+               pdp_rdma_reg_write(D_DATA_CUBE_IN_HEIGHT,
+                               pdp_surface->src_data.height - 1);
+               pdp_rdma_reg_write(D_DATA_CUBE_IN_CHANNEL,
+                               pdp_surface->src_data.channel - 1);
+
+               high = HIGH32BITS(input_address);
+               low  = LOW32BITS(input_address);
+               pdp_rdma_reg_write(D_SRC_BASE_ADDR_HIGH, high);
+               pdp_rdma_reg_write(D_SRC_BASE_ADDR_LOW, low);
+               pdp_rdma_reg_write(D_SRC_LINE_STRIDE,
+                               pdp_surface->src_data.line_stride);
+               pdp_rdma_reg_write(D_SRC_SURFACE_STRIDE,
+                               pdp_surface->src_data.surf_stride);
+
+               reg = (map_precision[pdp_op->precision]
+                       << SHIFT(PDP_RDMA_D_DATA_FORMAT_0, INPUT_DATA));
+               pdp_rdma_reg_write(D_DATA_FORMAT, reg);
+
+               reg = map_ram[pdp_surface->src_data.type]
+                       << SHIFT(PDP_RDMA_D_SRC_RAM_CFG_0, SRC_RAM_TYPE);
+               pdp_rdma_reg_write(D_SRC_RAM_CFG, reg);
+
+               reg = ((pdp_op->split_num - 1)
+                        << SHIFT(PDP_RDMA_D_OPERATION_MODE_CFG_0, SPLIT_NUM));
+               pdp_rdma_reg_write(D_OPERATION_MODE_CFG, reg);
+
+               reg = (map_pool_kernel[pdp_op->pool_width]
+                       << SHIFT(PDP_RDMA_D_POOLING_KERNEL_CFG_0,
+                                                       KERNEL_WIDTH)) |
+                       ((pdp_op->stride_x - 1)
+                       << SHIFT(PDP_RDMA_D_POOLING_KERNEL_CFG_0,
+                                                       KERNEL_STRIDE_WIDTH));
+               pdp_rdma_reg_write(D_POOLING_KERNEL_CFG, reg);
+
+               reg = (pdp_op->pad_left
+                       << SHIFT(PDP_RDMA_D_POOLING_PADDING_CFG_0, PAD_WIDTH));
+               pdp_rdma_reg_write(D_POOLING_PADDING_CFG, reg);
+
+               reg = ((pdp_op->partial_in_width_first == 0 ? 0 :
+                               pdp_op->partial_in_width_first - 1)
+                       << SHIFT(PDP_RDMA_D_PARTIAL_WIDTH_IN_0,
+                               PARTIAL_WIDTH_IN_FIRST)) |
+                       ((pdp_op->partial_in_width_mid == 0 ? 0 :
+                               pdp_op->partial_in_width_mid - 1)
+                       << SHIFT(PDP_RDMA_D_PARTIAL_WIDTH_IN_0,
+                               PARTIAL_WIDTH_IN_MID)) |
+                       ((pdp_op->partial_in_width_last == 0 ? 0 :
+                               pdp_op->partial_in_width_last - 1)
+                       << SHIFT(PDP_RDMA_D_PARTIAL_WIDTH_IN_0,
+                               PARTIAL_WIDTH_IN_LAST));
+               pdp_rdma_reg_write(D_PARTIAL_WIDTH_IN, reg);
+       } else {
+               ASSERT_GOTO(pdp_op->split_num == 1, ret,
+                                       ERR(INVALID_INPUT), exit);
+       }
+
+       reg = ((pdp_surface->src_data.width - 1)
+               << SHIFT(PDP_D_DATA_CUBE_IN_WIDTH_0, CUBE_IN_WIDTH));
+       pdp_reg_write(D_DATA_CUBE_IN_WIDTH, reg);
+
+       reg = ((pdp_surface->src_data.height - 1)
+               << SHIFT(PDP_D_DATA_CUBE_IN_HEIGHT_0, CUBE_IN_HEIGHT));
+       pdp_reg_write(D_DATA_CUBE_IN_HEIGHT, reg);
+
+       reg = ((pdp_surface->src_data.channel - 1)
+               << SHIFT(PDP_D_DATA_CUBE_IN_CHANNEL_0, CUBE_IN_CHANNEL));
+       pdp_reg_write(D_DATA_CUBE_IN_CHANNEL, reg);
+
+       reg = ((pdp_surface->dst_data.width - 1)
+               << SHIFT(PDP_D_DATA_CUBE_OUT_WIDTH_0, CUBE_OUT_WIDTH));
+       pdp_reg_write(D_DATA_CUBE_OUT_WIDTH, reg);
+
+       reg = ((pdp_surface->dst_data.height - 1)
+               << SHIFT(PDP_D_DATA_CUBE_OUT_HEIGHT_0, CUBE_OUT_HEIGHT));
+       pdp_reg_write(D_DATA_CUBE_OUT_HEIGHT, reg);
+
+       reg = ((pdp_surface->dst_data.channel - 1)
+               << SHIFT(PDP_D_DATA_CUBE_OUT_CHANNEL_0, CUBE_OUT_CHANNEL));
+       pdp_reg_write(D_DATA_CUBE_OUT_CHANNEL, reg);
+
+       reg = (map_pool[pdp_op->pool_mode]
+               << SHIFT(PDP_D_OPERATION_MODE_CFG_0, POOLING_METHOD)) |
+               (get_fly_mode(pdp_surface->src_data.type)
+               << SHIFT(PDP_D_OPERATION_MODE_CFG_0, FLYING_MODE)) |
+               ((pdp_op->split_num - 1)
+               << SHIFT(PDP_D_OPERATION_MODE_CFG_0, SPLIT_NUM));
+       pdp_reg_write(D_OPERATION_MODE_CFG, reg);
+
+       reg = ((pdp_op->partial_in_width_first == 0 ? 0 :
+                       pdp_op->partial_in_width_first-1)
+               << SHIFT(PDP_D_PARTIAL_WIDTH_IN_0, PARTIAL_WIDTH_IN_FIRST)) |
+               ((pdp_op->partial_in_width_mid == 0 ? 0 :
+                       pdp_op->partial_in_width_mid-1)
+               << SHIFT(PDP_D_PARTIAL_WIDTH_IN_0, PARTIAL_WIDTH_IN_MID)) |
+               ((pdp_op->partial_in_width_last == 0 ? 0 :
+                       pdp_op->partial_in_width_last-1)
+               << SHIFT(PDP_D_PARTIAL_WIDTH_IN_0, PARTIAL_WIDTH_IN_LAST));
+       pdp_reg_write(D_PARTIAL_WIDTH_IN, reg);
+
+       reg = ((pdp_op->partial_width_first == 0 ? 0 :
+                       pdp_op->partial_width_first-1)
+               << SHIFT(PDP_D_PARTIAL_WIDTH_OUT_0, PARTIAL_WIDTH_OUT_FIRST)) |
+               ((pdp_op->partial_width_mid == 0 ? 0 :
+                       pdp_op->partial_width_mid-1)
+               << SHIFT(PDP_D_PARTIAL_WIDTH_OUT_0, PARTIAL_WIDTH_OUT_MID))   |
+               ((pdp_op->partial_width_last == 0 ? 0 :
+                       pdp_op->partial_width_last-1)
+               << SHIFT(PDP_D_PARTIAL_WIDTH_OUT_0, PARTIAL_WIDTH_OUT_LAST));
+       pdp_reg_write(D_PARTIAL_WIDTH_OUT, reg);
+
+       reg = (map_pool_kernel[pdp_op->pool_width]
+               << SHIFT(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_WIDTH)) |
+               (map_pool_kernel[pdp_op->pool_height]
+               << SHIFT(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_HEIGHT))|
+               ((pdp_op->stride_x - 1)
+               << SHIFT(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_STRIDE_WIDTH)) |
+               ((pdp_op->stride_y - 1)
+               << SHIFT(PDP_D_POOLING_KERNEL_CFG_0, KERNEL_STRIDE_HEIGHT));
+       pdp_reg_write(D_POOLING_KERNEL_CFG, reg);
+
+       pdp_reg_write(D_RECIP_KERNEL_WIDTH,
+                       recip_kernel_size[pdp_op->precision ==
+                                       PRECISION_FP16][pdp_op->pool_width]);
+       pdp_reg_write(D_RECIP_KERNEL_HEIGHT,
+                       recip_kernel_size[pdp_op->precision ==
+                                       PRECISION_FP16][pdp_op->pool_height]);
+
+       reg = (pdp_op->pad_left
+               << SHIFT(PDP_D_POOLING_PADDING_CFG_0, PAD_LEFT)) |
+               (pdp_op->pad_right
+               << SHIFT(PDP_D_POOLING_PADDING_CFG_0, PAD_RIGHT)) |
+               (pdp_op->pad_top
+               << SHIFT(PDP_D_POOLING_PADDING_CFG_0, PAD_TOP)) |
+               (pdp_op->pad_bottom
+               << SHIFT(PDP_D_POOLING_PADDING_CFG_0, PAD_BOTTOM));
+       if (pdp_op->precision == PRECISION_FP16) {
+               int32_t i;
+
+               for (i = 0; i < 7; i++)
+                       ASSERT_GOTO(pdp_op->padding_value[i] == 0, ret,
+                                               ERR(INVALID_INPUT), exit);
+       }
+
+       pdp_reg_write(D_POOLING_PADDING_CFG, reg);
+       pdp_reg_write(D_POOLING_PADDING_VALUE_1_CFG, pdp_op->padding_value[0]);
+       pdp_reg_write(D_POOLING_PADDING_VALUE_2_CFG, pdp_op->padding_value[1]);
+       pdp_reg_write(D_POOLING_PADDING_VALUE_3_CFG, pdp_op->padding_value[2]);
+       pdp_reg_write(D_POOLING_PADDING_VALUE_4_CFG, pdp_op->padding_value[3]);
+       pdp_reg_write(D_POOLING_PADDING_VALUE_5_CFG, pdp_op->padding_value[4]);
+       pdp_reg_write(D_POOLING_PADDING_VALUE_6_CFG, pdp_op->padding_value[5]);
+       pdp_reg_write(D_POOLING_PADDING_VALUE_7_CFG, pdp_op->padding_value[6]);
+
+       if (pdp_surface->src_data.type != DLA_MEM_HW) {
+               pdp_reg_write(D_SRC_LINE_STRIDE,
+                               pdp_surface->src_data.line_stride);
+               pdp_reg_write(D_SRC_SURFACE_STRIDE,
+                               pdp_surface->src_data.surf_stride);
+       }
+
+       high = HIGH32BITS(output_address);
+       low = LOW32BITS(output_address);
+       pdp_reg_write(D_DST_BASE_ADDR_LOW, low);
+       pdp_reg_write(D_DST_BASE_ADDR_HIGH, high);
+
+       pdp_reg_write(D_DST_LINE_STRIDE, pdp_surface->dst_data.line_stride);
+       pdp_reg_write(D_DST_SURFACE_STRIDE, pdp_surface->dst_data.surf_stride);
+
+       reg = (map_ram[pdp_surface->dst_data.type]
+               << SHIFT(PDP_D_DST_RAM_CFG_0, DST_RAM_TYPE));
+       pdp_reg_write(D_DST_RAM_CFG, reg);
+
+       reg = (map_precision[pdp_op->precision]
+               << SHIFT(PDP_D_DATA_FORMAT_0, INPUT_DATA));
+       pdp_reg_write(D_DATA_FORMAT, reg);
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+int
+dla_pdp_is_ready(struct dla_processor *processor,
+                          struct dla_processor_group *group)
+{
+       return 1;
+}
+
+void
+dla_pdp_dump_config(struct dla_processor_group *group)
+{
+       struct dla_pdp_op_desc *pdp_op;
+       struct dla_pdp_surface_desc *pdp_surface;
+
+       pdp_surface = &group->surface_desc->pdp_surface;
+       pdp_op = &group->operation_desc->pdp_op;
+
+       dla_debug_pdp_surface_desc(pdp_surface, group->roi_index);
+       dla_debug_pdp_op_desc(pdp_op, group->roi_index);
+}
+
+int
+dla_pdp_program(struct dla_processor_group *group)
+{
+       int32_t ret;
+
+       dla_trace("Enter: %s", __func__);
+
+       if (!group) {
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       dla_enable_intr(MASK(GLB_S_INTR_MASK_0, PDP_DONE_MASK1) |
+                       MASK(GLB_S_INTR_MASK_0, PDP_DONE_MASK0));
+
+       ret = processor_pdp_program(group);
+       if (ret)
+               goto exit;
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}

diff --git a/drivers/nvdla/rubik.c b/drivers/nvdla/rubik.c
new file mode 100644 (file)
index 0000000..dd5196e
--- /dev/null
+++ b/drivers/nvdla/rubik.c
@@ -0,0 +1,292 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "common.h"
+#include "dla_engine_internal.h"
+#include "engine_debug.h"
+
+static uint8_t map_rubik_mode[] = {
+       FIELD_ENUM(RBK_D_MISC_CFG_0, RUBIK_MODE, CONTRACT),
+       FIELD_ENUM(RBK_D_MISC_CFG_0, RUBIK_MODE, SPLIT),
+       FIELD_ENUM(RBK_D_MISC_CFG_0, RUBIK_MODE, MERGE),
+};
+
+static uint8_t  map_ram_type[] = {
+       FIELD_ENUM(RBK_D_DAIN_RAM_TYPE_0, DATAIN_RAM_TYPE, MCIF),
+       FIELD_ENUM(RBK_D_DAIN_RAM_TYPE_0, DATAIN_RAM_TYPE, CVIF),
+};
+
+static uint8_t  map_precision[] = {
+       FIELD_ENUM(RBK_D_MISC_CFG_0, IN_PRECISION, INT8),
+       FIELD_ENUM(RBK_D_MISC_CFG_0, IN_PRECISION, INT16),
+       FIELD_ENUM(RBK_D_MISC_CFG_0, IN_PRECISION, FP16),
+};
+
+static uint8_t map_bpe[] = {
+       BPE_PRECISION_INT8,
+       BPE_PRECISION_INT16,
+       BPE_PRECISION_FP16,
+};
+
+#if STAT_ENABLE
+void
+dla_rubik_stat_data(struct dla_processor *processor,
+                                       struct dla_processor_group *group)
+{
+       uint64_t end_time = 0;
+       struct dla_rubik_stat_desc *rubik_stat;
+
+       rubik_stat = &processor->stat_data_desc->rubik_stat;
+
+       end_time = dla_get_time_us();
+
+       rubik_stat->read_stall = rubik_reg_read(D_PERF_READ_STALL);
+       rubik_stat->write_stall = rubik_reg_read(D_PERF_WRITE_STALL);
+       rubik_stat->runtime = (uint32_t)(end_time - group->start_time);
+}
+
+void
+dla_rubik_dump_stat(struct dla_processor *processor)
+{
+       struct dla_rubik_stat_desc *rubik_stat;
+
+       rubik_stat = &processor->stat_data_desc->rubik_stat;
+
+       dla_debug_rubik_stats(rubik_stat);
+}
+#endif /* STAT_ENABLE */
+
+void
+dla_rubik_set_producer(int32_t group_id, int32_t __unused)
+{
+       uint32_t reg;
+
+       /**
+        * set producer pointer for all sub-modules
+        */
+       reg = group_id << SHIFT(RBK_S_POINTER_0, PRODUCER);
+       rubik_reg_write(S_POINTER, reg);
+}
+
+int
+dla_rubik_enable(struct dla_processor_group *group)
+{
+       uint32_t reg;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_trace("Enter: %s", __func__);
+
+       if (engine->stat_enable == (uint32_t)1) {
+               rubik_reg_write(D_PERF_ENABLE, 1);
+               group->start_time = dla_get_time_us();
+       }
+
+       /**
+        * enable all sub-modules
+        */
+       reg = FIELD_ENUM(RBK_D_OP_ENABLE_0, OP_EN, ENABLE);
+       rubik_reg_write(D_OP_ENABLE, reg);
+
+       dla_trace("Exit: %s", __func__);
+
+       RETURN(0);
+}
+
+void
+dla_rubik_rdma_check(struct dla_processor_group *group)
+{
+       group->is_rdma_needed = 0;
+}
+
+static int32_t
+processor_rubik_program(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       uint32_t reg, high, low;
+       uint64_t input_address = 0;
+       uint64_t output_address = 0;
+       struct dla_engine *engine = dla_get_engine();
+       struct dla_rubik_op_desc *rubik_op;
+       struct dla_rubik_surface_desc *rubik_surface;
+
+       dla_trace("Enter: %s", __func__);
+
+       rubik_op = &group->operation_desc->rubik_op;
+       rubik_surface = &group->surface_desc->rubik_surface;
+
+       /* Argument check */
+       ASSERT_GOTO((rubik_surface->src_data.type != DLA_MEM_HW),
+               ret, ERR(INVALID_INPUT), exit);
+       ASSERT_GOTO((rubik_surface->dst_data.type != DLA_MEM_HW),
+               ret, ERR(INVALID_INPUT), exit);
+
+       /* get the addresses from task descriptor */
+       ret = dla_read_input_address(&rubik_surface->src_data,
+                                               &input_address,
+                                               group->op_desc->index,
+                                               group->roi_index,
+                                               1);
+       if (ret)
+               goto exit;
+
+       dla_get_dma_cube_address(engine->driver_context,
+                               engine->task->task_data,
+                               rubik_surface->dst_data.address,
+                               rubik_surface->dst_data.offset,
+                               (void *)&output_address,
+                               DESTINATION_DMA);
+
+       /* config rubik */
+       reg = (((uint32_t)map_rubik_mode[rubik_op->mode]) <<
+                       SHIFT(RBK_D_MISC_CFG_0, RUBIK_MODE)) |
+                       (((uint32_t)map_precision[rubik_op->precision]) <<
+                       SHIFT(RBK_D_MISC_CFG_0, IN_PRECISION));
+       rubik_reg_write(D_MISC_CFG, reg);
+       reg = (((uint32_t)map_ram_type[rubik_surface->src_data.type]) <<
+                       SHIFT(RBK_D_DAIN_RAM_TYPE_0, DATAIN_RAM_TYPE));
+       rubik_reg_write(D_DAIN_RAM_TYPE, reg);
+       reg =  ((rubik_surface->src_data.width-1) <<
+                       SHIFT(RBK_D_DATAIN_SIZE_0_0, DATAIN_WIDTH)) |
+                       ((rubik_surface->src_data.height-1) <<
+                       SHIFT(RBK_D_DATAIN_SIZE_0_0, DATAIN_HEIGHT));
+       rubik_reg_write(D_DATAIN_SIZE_0, reg);
+       reg =  ((rubik_surface->src_data.channel-1) <<
+                       SHIFT(RBK_D_DATAIN_SIZE_1_0, DATAIN_CHANNEL));
+       rubik_reg_write(D_DATAIN_SIZE_1, reg);
+
+       high = HIGH32BITS(input_address);
+       low = LOW32BITS(input_address);
+       rubik_reg_write(D_DAIN_ADDR_LOW, low);
+       rubik_reg_write(D_DAIN_ADDR_HIGH, high);
+       if (rubik_op->mode == RUBIK_MODE_MERGE) {
+               ASSERT_GOTO((rubik_surface->src_data.plane_stride != 0),
+                       ret, ERR(INVALID_INPUT), exit);
+               ASSERT_GOTO(((rubik_surface->src_data.plane_stride&0x1F) == 0),
+                       ret, ERR(INVALID_INPUT), exit);
+               rubik_reg_write(D_DAIN_PLANAR_STRIDE,
+                       rubik_surface->src_data.plane_stride);
+       } else {
+               rubik_reg_write(D_DAIN_SURF_STRIDE,
+                       rubik_surface->src_data.surf_stride);
+       }
+       rubik_reg_write(D_DAIN_LINE_STRIDE,
+                               rubik_surface->src_data.line_stride);
+
+       reg = (((uint32_t)map_ram_type[rubik_surface->dst_data.type]) <<
+                       SHIFT(RBK_D_DAOUT_RAM_TYPE_0, DATAOUT_RAM_TYPE));
+       rubik_reg_write(D_DAOUT_RAM_TYPE, reg);
+       reg =  ((rubik_surface->dst_data.channel-1) <<
+                       SHIFT(RBK_D_DATAOUT_SIZE_1_0, DATAOUT_CHANNEL));
+       rubik_reg_write(D_DATAOUT_SIZE_1, reg);
+
+       high = HIGH32BITS(output_address);
+       low = LOW32BITS(output_address);
+       rubik_reg_write(D_DAOUT_ADDR_LOW, low);
+       rubik_reg_write(D_DAOUT_ADDR_HIGH, high);
+
+       rubik_reg_write(D_DAOUT_LINE_STRIDE,
+                       rubik_surface->dst_data.line_stride);
+       if (rubik_op->mode != RUBIK_MODE_SPLIT) {
+               rubik_reg_write(D_DAOUT_SURF_STRIDE,
+                               rubik_surface->dst_data.surf_stride);
+               if (rubik_op->mode == RUBIK_MODE_CONTRACT) {
+                       reg = ((rubik_surface->dst_data.channel *
+                               map_bpe[rubik_op->precision] + 31) >> 5) *
+                               rubik_surface->src_data.surf_stride;
+                       rubik_reg_write(D_CONTRACT_STRIDE_0, reg);
+
+                       reg = rubik_op->stride_y *
+                               rubik_surface->dst_data.line_stride;
+                       rubik_reg_write(D_CONTRACT_STRIDE_1, reg);
+
+                       reg = (((uint32_t)(rubik_op->stride_x-1)) <<
+                       SHIFT(RBK_D_DECONV_STRIDE_0, DECONV_X_STRIDE)) |
+                               (((uint32_t)(rubik_op->stride_y-1)) <<
+                       SHIFT(RBK_D_DECONV_STRIDE_0, DECONV_Y_STRIDE));
+                       rubik_reg_write(D_DECONV_STRIDE, reg);
+               }
+       } else {
+               rubik_reg_write(D_DAOUT_PLANAR_STRIDE,
+                               rubik_surface->dst_data.plane_stride);
+       }
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+int
+dla_rubik_is_ready(struct dla_processor *processor,
+                            struct dla_processor_group *group)
+{
+       return 1;
+}
+
+void
+dla_rubik_dump_config(struct dla_processor_group *group)
+{
+       struct dla_rubik_op_desc *rubik_op;
+       struct dla_rubik_surface_desc *rubik_surface;
+
+       rubik_surface = &group->surface_desc->rubik_surface;
+       rubik_op = &group->operation_desc->rubik_op;
+
+       dla_debug_rubik_surface_desc(rubik_surface, group->roi_index);
+       dla_debug_rubik_op_desc(rubik_op, group->roi_index);
+}
+
+int
+dla_rubik_program(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_trace("Enter: %s", __func__);
+
+       if (!engine->config_data->rubik_enable) {
+               dla_error("RUBIK is not supported for this configuration\n");
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       dla_enable_intr(MASK(GLB_S_INTR_MASK_0, RUBIK_DONE_MASK1) |
+                       MASK(GLB_S_INTR_MASK_0, RUBIK_DONE_MASK0));
+
+       ret = processor_rubik_program(group);
+       if (ret)
+               goto exit;
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}

diff --git a/drivers/nvdla/scheduler.c b/drivers/nvdla/scheduler.c
new file mode 100644 (file)
index 0000000..6a4cc24
--- /dev/null
+++ b/drivers/nvdla/scheduler.c
@@ -0,0 +1,1160 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_engine.h>
+#include <dla_err.h>
+#include <dla_interface.h>
+
+#include "dla_engine_internal.h"
+#include "engine_debug.h"
+
+#define MAX_NUM_ADDRESSES      256
+
+static uint64_t roi_array_length __aligned(8);
+static struct dla_network_desc network;
+
+static int
+dla_update_consumers(struct dla_processor_group *group,
+                       struct dla_common_op_desc *op, uint8_t event);
+
+static int32_t
+dla_read_address_list(struct dla_engine *engine)
+{
+       RETURN(0);
+}
+
+int32_t
+dla_read_lut(struct dla_engine *engine, int16_t index, void *dst)
+{
+       int32_t ret = 0;
+       uint64_t src_addr;
+
+       if (index == -1) {
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       src_addr = engine->task->lut_data_addr;
+
+       ret = dla_data_read(engine->driver_context,
+                       engine->task->task_data,
+                       src_addr, (void *)dst,
+                       sizeof(struct dla_lut_param),
+                       (sizeof(struct dla_lut_param) * (uint64_t)index));
+
+exit:
+       RETURN(ret);
+}
+
+static int
+dla_op_enabled(struct dla_processor_group *group)
+{
+       int32_t ret;
+       struct dla_common_op_desc *op_desc;
+
+       dla_debug("Enter: %s\n", __func__);
+       op_desc = group->op_desc;
+
+       group->active = 1;
+
+       /* update dependency graph for this task */
+       ret = dla_update_consumers(group, op_desc, DLA_EVENT_OP_ENABLED);
+       dla_debug("Exit: %s\n", __func__);
+
+       RETURN(ret);
+}
+
+static int
+dla_op_programmed(struct dla_processor *processor,
+                 struct dla_processor_group *group,
+                 uint8_t rdma_id)
+{
+       int32_t ret;
+       struct dla_common_op_desc *op_desc;
+
+       dla_debug("Enter: %s\n", __func__);
+       op_desc = group->op_desc;
+
+       group->pending = 0;
+
+       /* update dependency graph for this task */
+       ret = dla_update_consumers(group, op_desc, DLA_EVENT_OP_PROGRAMMED);
+       dla_debug("Exit: %s\n", __func__);
+
+       RETURN(ret);
+}
+
+static int32_t
+dla_read_config(struct dla_task *task, struct dla_processor *processor,
+                                       struct dla_processor_group *group)
+{
+       int32_t ret;
+       uint64_t base;
+       int16_t index;
+       uint8_t roi_index;
+       struct dla_engine *engine;
+
+       dla_debug("Enter: %s\n", __func__);
+
+       engine = dla_get_engine();
+
+       roi_index = group->roi_index;
+       index = group->op_desc->index;
+
+       base = (sizeof(union dla_operation_container) *
+                       (uint64_t)engine->network->num_operations *
+                       (uint64_t)roi_index);
+       base = base + (sizeof(union dla_operation_container) *
+                       (uint64_t)index);
+
+       LOG_EVENT(roi_index, group->id, processor->op_type,
+                                       LOG_READ_OP_CONFIG_START);
+
+       ret = dla_data_read(engine->driver_context, task->task_data,
+                               task->operation_desc_addr,
+                               (void *)group->operation_desc,
+                               sizeof(union dla_operation_container),
+                               base);
+       if (ret)
+               goto exit;
+
+       LOG_EVENT(roi_index, group->id, processor->op_type,
+                                       LOG_READ_OP_CONFIG_END);
+
+       base = (sizeof(union dla_surface_container) *
+                       (uint64_t)engine->network->num_operations *
+                       (uint64_t)roi_index);
+
+       base = base + (sizeof(union dla_surface_container) *
+                       (uint64_t)index);
+
+       LOG_EVENT(roi_index, group->id, processor->op_type,
+                                       LOG_READ_SURF_CONFIG_START);
+
+       ret = dla_data_read(engine->driver_context, task->task_data,
+                               task->surface_desc_addr,
+                               (void *)group->surface_desc,
+                               sizeof(union dla_surface_container), base);
+       if (ret)
+               goto exit;
+
+       LOG_EVENT(roi_index, group->id, processor->op_type,
+                                       LOG_READ_SURF_CONFIG_END);
+
+       processor->dump_config(group);
+
+exit:
+       dla_debug("Exit: %s\n", __func__);
+       RETURN(ret);
+}
+
+static void
+dla_reset_group(struct dla_processor_group *group)
+{
+       int32_t i;
+
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               dla_put_op_desc(group->consumers[i]);
+               group->consumers[i] = NULL;
+       }
+
+       dla_put_op_desc(group->fused_parent);
+       group->fused_parent = NULL;
+
+       dla_put_op_desc(group->op_desc);
+       group->op_desc = NULL;
+}
+
+static int
+dla_prepare_operation(struct dla_processor *processor,
+                       struct dla_common_op_desc *op_desc,
+                       uint8_t roi_index, uint32_t *group_number)
+{
+       int32_t ret = 0;
+       uint8_t group_id;
+       uint8_t rdma_id;
+       struct dla_processor_group *group;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter: %s\n", __func__);
+
+       /*
+        * If not already programmed then find out if
+        * processor is free and which group is free
+        */
+       ret = utils_get_free_group(processor, &group_id, &rdma_id);
+       if (ret) {
+               dla_debug("processor:%s register groups are busy\n",
+                       processor->name);
+               goto exit;
+       } else {
+               dla_info("processor:%s group:%d, rdma_group:%d available\n",
+                               processor->name, group_id, rdma_id);
+       }
+       *group_number = group_id;
+       group = &processor->groups[group_id];
+
+       /*
+        * update operation descriptor
+        */
+       group->op_desc = op_desc;
+       dla_get_refcount(op_desc);
+       group->id = group_id;
+       group->roi_index = roi_index;
+       group->rdma_id = rdma_id;
+
+       ret = dla_read_config(engine->task, processor, group);
+       if (ret)
+               goto exit;
+
+       group->pending = 1;
+
+       processor->group_status |= (1 << group->id);
+
+       processor->rdma_check(group);
+       if (group->is_rdma_needed) {
+               group->rdma_id = rdma_id;
+               processor->rdma_status |= (1 << rdma_id);
+       }
+
+       processor->tail_op = op_desc;
+exit:
+       dla_debug("Exit: %s status=%d\n", __func__, ret);
+       RETURN(ret);
+}
+
+static int
+dla_program_operation(struct dla_processor *processor,
+                       struct dla_processor_group *group)
+{
+       int32_t i;
+       int32_t ret = 0;
+       struct dla_common_op_desc *op_desc;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter: %s\n", __func__);
+
+       dla_info("Program %s operation index %d ROI %d Group[%d]\n",
+                                       processor->name,
+                                       group->op_desc->index,
+                                       group->roi_index,
+                                       group->id);
+
+       group->programming = 1;
+
+       op_desc = group->op_desc;
+
+       processor->set_producer(group->id, group->rdma_id);
+
+       LOG_EVENT(group->roi_index, group->id, processor->op_type,
+                                               LOG_PROGRAM_START);
+
+       ret = processor->program(group);
+       if (ret)
+               goto exit;
+
+       LOG_EVENT(group->roi_index, group->id, processor->op_type,
+                                               LOG_PROGRAM_END);
+
+       /*
+        * Pre-fetch consumers
+        */
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               group->consumers[i] = dla_get_op_desc(engine->task,
+                                       op_desc->consumers[i].index, i,
+                                       group->roi_index);
+       }
+
+       group->fused_parent = dla_get_op_desc(engine->task,
+                                       op_desc->fused_parent.index,
+                                       op_desc->op_type - 1,
+                                       group->roi_index);
+
+       if (group->fused_parent != NULL) {
+               if (group->fused_parent->op_type != (op_desc->op_type - 1)) {
+                       dla_warn("Invalid fused op type");
+                       ret = ERR(INVALID_INPUT);
+                       goto exit;
+               }
+       }
+
+       ret = dla_op_programmed(processor, group, group->rdma_id);
+       if (!ret)
+               goto exit;
+
+exit:
+       group->programming = 0;
+       dla_debug("Exit: %s status=%d\n", __func__, ret);
+       RETURN(ret);
+}
+
+static int
+dla_enable_operation(struct dla_processor *processor,
+                       struct dla_common_op_desc *op_desc)
+{
+       int32_t ret = 0;
+       int32_t group_id;
+       struct dla_engine *engine;
+       struct dla_processor_group *group;
+
+       dla_debug("Enter: %s\n", __func__);
+       assert(op_desc->dependency_count == 0);
+
+       /*
+        * If some operation has reported error then skip
+        * enabling next operations
+        */
+       engine = dla_get_engine();
+       if (engine->status)
+               goto exit;
+
+       /*
+        * Find out if operation is already programmed
+        */
+       group_id = 0;
+       group = &processor->groups[group_id];
+       if ((processor->group_status & (1 << group_id)) &&
+                       group->op_desc->index == op_desc->index &&
+                       group->roi_index == op_desc->roi_index &&
+                       !group->pending)
+               goto enable_op;
+
+       group_id = 1;
+       group = &processor->groups[group_id];
+       if ((processor->group_status & (1 << group_id)) &&
+                       group->op_desc->index == op_desc->index &&
+                       group->roi_index == op_desc->roi_index &&
+                       !group->pending)
+               goto enable_op;
+
+       /*
+        * Operation is not programmed yet, ignore
+        */
+       dla_debug("exit %s without actual enable due to processor "
+                               "hasn't been programmed\n", __func__);
+       goto exit;
+
+enable_op:
+       /*
+        * If this event is triggered as part of programming same
+        * group then skip enable, it will get enabled after programming
+        * is complete
+        */
+       if (group->programming)
+               goto exit;
+
+       if (group->active) {
+               dla_debug("Processor:%s already enabled on group:%d\n",
+                       processor->name, group_id);
+               goto exit;
+       }
+
+       dla_info("Enable %s operation index %d ROI %d\n",
+                                       processor->name,
+                                       group->op_desc->index,
+                                       group->roi_index);
+
+       processor->set_producer(group->id, group->rdma_id);
+
+       LOG_EVENT(group->roi_index, group->id, processor->op_type,
+                                               LOG_OPERATION_START);
+
+       ret = processor->enable(group);
+       if (ret)
+               goto exit;
+
+       ret = dla_op_enabled(group);
+exit:
+       dla_debug("Exit: %s status=%d\n", __func__, ret);
+       RETURN(ret);
+}
+
+static int
+dla_submit_operation(struct dla_processor *processor,
+                       struct dla_common_op_desc *op_desc,
+                       uint8_t roi_index)
+{
+       int32_t err;
+       uint32_t group_id = 0;
+
+       dla_debug("Enter: %s\n", __func__);
+
+       dla_info("Prepare %s operation index %d ROI %d dep_count %d\n",
+                       processor->name, op_desc->index, roi_index,
+                       op_desc->dependency_count);
+       err = dla_prepare_operation(processor, op_desc, roi_index, &group_id);
+       if (err)
+               goto exit;
+
+       if (!processor->is_ready(processor, &processor->groups[group_id]))
+               goto exit;
+
+       err = dla_program_operation(processor, &processor->groups[group_id]);
+       if (err)
+               goto exit;
+
+       if (op_desc->dependency_count == 0)
+               err = dla_enable_operation(processor, op_desc);
+
+exit:
+       dla_debug("Exit: %s\n", __func__);
+       RETURN(err);
+}
+
+/*
+ * Dequeue next operation of same type from list of operations
+ */
+static int32_t
+dla_dequeue_operation(struct dla_engine *engine,
+                       struct dla_processor *processor)
+{
+       int32_t ret = 0;
+       int16_t index;
+       struct dla_common_op_desc *consumer;
+
+       dla_debug("Enter: %s\n", __func__);
+
+       if (engine->status) {
+               dla_debug("Skip dequeue op as engine has reported error\n");
+               goto exit;
+       }
+
+       /*
+        * If we are done processing all ROIs for current op then
+        * load next op of same type otherwise reload same op for
+        * next ROI.
+        */
+       if (processor->roi_index == (engine->network->num_rois - 1)) {
+               index = processor->tail_op->consumers[processor->op_type].index;
+               if (-1 == index) {
+                       /*
+                        * It means we are done processing
+                        * all ops of this type
+                        */
+                       dla_debug("exit %s as there's no further operation\n",
+                               processor->name);
+                       goto exit;
+               }
+               processor->roi_index = 0;
+       } else {
+               processor->roi_index++;
+               index = processor->tail_op->index;
+       }
+
+       dla_debug("Dequeue op from %s processor, index=%d ROI=%d\n",
+                       processor->name, index, processor->roi_index);
+
+       /*
+        * Get operation descriptor
+        */
+       consumer = dla_get_op_desc(engine->task, index,
+                               processor->op_type, processor->roi_index);
+       if (consumer == NULL) {
+               ret = ERR(NO_MEM);
+               dla_error("Failed to allocate op_desc");
+               goto exit;
+       }
+
+       ret = dla_submit_operation(processor, consumer, processor->roi_index);
+       dla_put_op_desc(consumer);
+
+exit:
+       dla_debug("Exit: %s\n", __func__);
+       RETURN(ret);
+}
+
+static int
+dla_update_dependency(struct dla_consumer *consumer,
+                       struct dla_common_op_desc *op_desc,
+                       uint8_t event, uint8_t roi_index)
+{
+       int32_t ret = 0;
+       struct dla_processor *processor;
+       struct dla_engine *engine = dla_get_engine();
+
+       if (consumer->index == -1)
+               goto exit;
+
+       /* Update dependency only if event matches */
+       if (event != consumer->event)
+               goto exit;
+
+       /*
+        * If consumer index is valid but op desc is NULL means
+        * op desc for consumer was not pre-fetched
+        */
+       if (op_desc == NULL) {
+               ret = ERR(INVALID_INPUT);
+               dla_error("Operation descriptor is NULL, consumer index %d",
+                               consumer->index);
+               goto exit;
+       }
+
+       assert(op_desc->dependency_count > 0);
+
+       dla_debug("Update dependency operation index %d ROI %d DEP_COUNT=%d\n",
+                                       op_desc->index, op_desc->roi_index,
+                                       op_desc->dependency_count);
+       op_desc->dependency_count--;
+
+       if (op_desc->dependency_count == 0) {
+               processor = &engine->processors[op_desc->op_type];
+               dla_debug("enable %s in %s as depdency are resolved\n",
+                       processor->name, __func__);
+
+               ret = dla_enable_operation(processor, op_desc);
+               if (ret)
+                       goto exit;
+       }
+exit:
+       RETURN(ret);
+}
+
+static int
+dla_update_consumers(struct dla_processor_group *group,
+                    struct dla_common_op_desc *op,
+                    uint8_t event)
+{
+       int32_t i;
+       int32_t ret = 0;
+       struct dla_engine *engine = dla_get_engine();
+
+       if (engine->status) {
+               dla_debug("Skip update as engine has reported error\n");
+               goto exit;
+       }
+
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               ret = dla_update_dependency(&op->consumers[i],
+                                               group->consumers[i],
+                                               event, group->roi_index);
+               if (ret) {
+                       dla_error("Failed to update dependency for "
+                               "consumer %d, ROI %d", i, group->roi_index);
+                       goto exit;
+               }
+       }
+
+       ret = dla_update_dependency(&op->fused_parent,
+                                       group->fused_parent,
+                                       event, group->roi_index);
+       if (ret) {
+               dla_error("Failed to update dependency for "
+                       "fused parent, ROI %d", group->roi_index);
+               goto exit;
+       }
+
+exit:
+       RETURN(ret);
+}
+
+/*
+ * Handle operation completion notification
+ */
+int
+dla_op_completion(struct dla_processor *processor,
+                 struct dla_processor_group *group)
+{
+       int32_t ret;
+#if STAT_ENABLE
+       uint64_t stat_data_address;
+       uint64_t stat_base;
+#endif /* STAT_ENABLE */
+       struct dla_task *task;
+       struct dla_common_op_desc *op_desc;
+       struct dla_processor_group *next_group;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_debug("Enter:%s processor %s group%u\n", __func__,
+                                       processor->name, group->id);
+
+       dla_info("Completed %s operation index %d ROI %d\n",
+                                       processor->name,
+                                       group->op_desc->index,
+                                       group->roi_index);
+
+       task = engine->task;
+
+       /*
+        * Mark OP as done only when all ROIs are done for that
+        * operation
+        */
+       if (group->roi_index == (engine->network->num_rois - 1))
+               engine->num_proc_hwl++;
+
+       op_desc = group->op_desc;
+
+#if STAT_ENABLE
+       if (engine->stat_enable == (uint32_t)1) {
+               processor->get_stat_data(processor, group);
+
+               processor->dump_stat(processor);
+
+               stat_data_address = (uint64_t)(engine->task->stat_data_addr +
+                               (sizeof(union dla_stat_container) *
+                               (uint64_t)(engine->network->num_operations) *
+                               (uint64_t)(op_desc->roi_index)));
+
+               stat_base = (stat_data_address +
+                               (sizeof(union dla_stat_container) *
+                               (uint64_t)op_desc->index));
+
+               /*
+                * Flush stat descriptor to DRAM
+                */
+               ret = dla_data_write(engine->driver_context, task->task_data,
+                                       (void *)(processor->stat_data_desc),
+                                       stat_base,
+                                       sizeof(union dla_stat_container),
+                                       0);
+               if (ret < 0)
+                       dla_error("Failed to write stats to DMA memory\n");
+       }
+#endif /* STAT_ENABLE */
+
+       /*
+        * Get an extra reference count to keep op descriptor
+        * in cache until this operation completes
+        */
+       dla_get_refcount(op_desc);
+
+       LOG_EVENT(group->roi_index, group->id, processor->op_type,
+                                               LOG_OPERATION_END);
+
+       processor->group_status &= ~(1 << group->id);
+       if (group->is_rdma_needed) {
+               group->is_rdma_needed = 0;
+               processor->rdma_status &= ~(1 << group->rdma_id);
+               group->rdma_id = 0;
+       }
+       group->active = 0;
+       group->lut_index = -1;
+       processor->last_group = group->id;
+
+       /*
+        * Switch consumer pointer to next group
+        */
+       processor->consumer_ptr = !group->id;
+
+       /*
+        * update dependency graph for this task
+        * TODO: Add proper error handling
+        */
+       ret = dla_update_consumers(group, op_desc, DLA_EVENT_OP_COMPLETED);
+       if (ret)
+               goto exit;
+
+       dla_info("%d HWLs done, totally %d layers\n",
+                               engine->num_proc_hwl,
+                               engine->network->num_operations);
+
+       /* free operation descriptor from cache */
+       dla_reset_group(group);
+
+       /* if not hwl pending, means network completed */
+       if (engine->network->num_operations == engine->num_proc_hwl) {
+               dla_put_op_desc(op_desc);
+               goto exit;
+       }
+
+       next_group = &processor->groups[!group->id];
+       if (next_group->pending && !engine->status) {
+               /*
+                * Next group must be ready here for programming,
+                * if not means it is an error
+                */
+               if (!processor->is_ready(processor, next_group))
+                       goto dequeue_op;
+
+               ret = dla_program_operation(processor, next_group);
+               if (ret)
+                       goto exit;
+
+               if (next_group->op_desc->dependency_count != 0)
+                       goto dequeue_op;
+
+               ret = dla_enable_operation(processor,
+                                          next_group->op_desc);
+               if (ret)
+                       goto exit;
+       }
+
+dequeue_op:
+       /* dequeue operation from this processor */
+       ret = dla_dequeue_operation(engine, processor);
+
+exit:
+       dla_put_op_desc(op_desc);
+       dla_debug("Exit:%s processor %s group%u status=%d\n",
+                               __func__, processor->name,
+                               group->id, ret);
+
+       RETURN(ret);
+}
+
+/*
+ * Read network configuration from DRAM, network descriptor address
+ * is always first in the address list. Network configuration contains
+ * offset in address list for addresses of other lists used to
+ * execute network
+ *
+ * @engine: Engine instance
+ * @return: 0 for success
+ */
+static int
+dla_read_network_config(struct dla_engine *engine)
+{
+       int32_t ret;
+       uint64_t network_addr;
+       struct dla_task *task = engine->task;
+
+       dla_debug("Enter:%s\n", __func__);
+
+       /*
+        * Read address list from DRAM to DMEM
+        */
+       ret = dla_read_address_list(engine);
+       if (ret) {
+               dla_error("Failed to read address list");
+               goto exit;
+       }
+
+       /*
+        * Read network descriptor address from address list. It is always
+        * at index 0.
+        */
+       ret = dla_get_dma_address(engine->driver_context, task->task_data,
+                                               0, (void *)&network_addr,
+                                               DESTINATION_PROCESSOR);
+       if (ret) {
+               dla_error("Failed to read network desc address");
+               goto exit;
+       }
+
+       /*
+        * Read network descriptor, it has information for a network
+        * such as all address indexes.
+        */
+       ret = dla_data_read(engine->driver_context, task->task_data,
+                               network_addr, (void *)&network,
+                               sizeof(struct dla_network_desc),
+                               0);
+       if (ret) {
+               dla_error("Failed to read network descriptor");
+               goto exit;
+       }
+
+       dla_debug_network_desc(&network);
+
+       if (network.num_operations == 0)
+               goto exit;
+
+       /*
+        * Read operation descriptor list address from address list
+        */
+       ret = dla_get_dma_address(engine->driver_context, task->task_data,
+                               network.operation_desc_index,
+                               (void *)&task->operation_desc_addr,
+                               DESTINATION_PROCESSOR);
+       if (ret) {
+               dla_error("Failed to read operation desc list address");
+               goto exit;
+       }
+
+       /*
+        * Read surface descriptor list address from address list
+        */
+       ret = dla_get_dma_address(engine->driver_context, task->task_data,
+                               network.surface_desc_index,
+                               (void *)&task->surface_desc_addr,
+                               DESTINATION_PROCESSOR);
+       if (ret) {
+               dla_error("Failed to read surface desc list address");
+               goto exit;
+       }
+
+       /*
+        * Read dependency graph address from address list
+        */
+       ret = dla_get_dma_address(engine->driver_context, task->task_data,
+                               network.dependency_graph_index,
+                               (void *)&task->dependency_graph_addr,
+                               DESTINATION_PROCESSOR);
+       if (ret) {
+               dla_error("Failed to ready dependency graph address");
+               goto exit;
+       }
+
+       /*
+        * Read LUT data list address from address list
+        */
+       if (network.num_luts) {
+               ret = dla_get_dma_address(engine->driver_context,
+                                       task->task_data,
+                                       network.lut_data_index,
+                                       (void *)&task->lut_data_addr,
+                                       DESTINATION_PROCESSOR);
+               if (ret) {
+                       dla_error("Failed to read LUT list address");
+                       goto exit;
+               }
+       }
+
+       /*
+        * Read address for ROI information
+        */
+       if (network.dynamic_roi) {
+               /*
+                * Read ROI array address from address list
+                */
+               ret = dla_get_dma_address(engine->driver_context,
+                                       task->task_data,
+                                       network.roi_array_index,
+                                       (void *)&task->roi_array_addr,
+                                       DESTINATION_PROCESSOR);
+               if (ret) {
+                       dla_error("Failed to read ROI array address");
+                       goto exit;
+               }
+
+               ret = dla_data_read(engine->driver_context, task->task_data,
+                                       task->roi_array_addr,
+                                       (void *)&roi_array_length,
+                                       sizeof(uint64_t),
+                                       0);
+               if (ret) {
+                       dla_error("Failed to read ROI array length");
+                       goto exit;
+               }
+
+               /*
+                * Number of ROIs detected can't be greater than maximum number
+                * ROIs this network can process
+                */
+               if (roi_array_length > network.num_rois) {
+                       dla_error("Invalid number of ROIs detected");
+                       ret = ERR(INVALID_INPUT);
+                       goto exit;
+               }
+
+               network.num_rois = roi_array_length;
+
+               /*
+                * Read surface address from address list
+                */
+               ret = dla_get_dma_address(engine->driver_context,
+                                               task->task_data,
+                                               network.surface_index,
+                                               (void *)&task->surface_addr,
+                                               DESTINATION_DMA);
+               if (ret) {
+                       dla_error("Failed to read surface address");
+                       goto exit;
+               }
+       }
+
+#if STAT_ENABLE
+       if (network.stat_list_index != -1) {
+               ret = dla_get_dma_address(engine->driver_context,
+                                               task->task_data,
+                                               network.stat_list_index,
+                                               (void *)&task->stat_data_addr,
+                                               DESTINATION_PROCESSOR);
+               if (ret) {
+                       dla_error("Failed to read stat address");
+                       goto exit;
+               }
+       }
+#endif /* STAT_ENABLE */
+
+exit:
+       dla_debug("Exit:%s status=%d\n", __func__, ret);
+       RETURN(ret);
+}
+
+static int
+dla_initiate_processors(struct dla_engine *engine)
+{
+       int32_t i;
+       int32_t ret = 0;
+       int16_t index;
+       struct dla_processor *processor;
+       struct dla_common_op_desc *consumer;
+       struct dla_network_desc *nw;
+
+       dla_debug("Enter: %s\n", __func__);
+
+       if (!engine) {
+               ret = ERR(INVALID_INPUT);
+               goto exit;
+       }
+
+       nw = engine->network;
+
+       /* Validate operation heads before initiating processors */
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               if (nw->op_head[i] >= nw->num_operations) {
+                       ret = ERR(INVALID_INPUT);
+                       dla_error("Invalid op_head %d for op %d",
+                                               nw->op_head[i], i);
+                       goto exit;
+               }
+       }
+
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               index = nw->op_head[i];
+
+               /* If there is no op for this type then continue */
+               if (-1 == index)
+                       continue;
+
+               consumer = dla_get_op_desc(engine->task, index, i, 0);
+               /*
+                * if consumer is NULL, it means either data copy error
+                * or cache insufficient - we should fix it
+                */
+               if (consumer == NULL) {
+                       dla_error("Failed to allocate memory for op_head[%d]=%d",
+                                                       i, index);
+                       ret = ERR(NO_MEM);
+                       goto exit;
+               }
+
+               processor = &engine->processors[consumer->op_type];
+
+               ret = dla_submit_operation(processor, consumer, 0);
+               dla_put_op_desc(consumer);
+               if (ret && ret != ERR(PROCESSOR_BUSY)) {
+                       dla_error("Failed to submit %s op from index %u\n",
+                                               processor->name, index);
+                       goto exit;
+               }
+
+               ret = dla_dequeue_operation(engine, processor);
+               if (ret) {
+                       dla_error("Failed to dequeue op for %s processor",
+                                                       processor->name);
+                       goto exit;
+               }
+       }
+exit:
+       dla_debug("Exit: %s status=%d\n", __func__, ret);
+       RETURN(ret);
+}
+
+static int
+dla_handle_events(struct dla_processor *processor)
+{
+       int32_t j;
+       int32_t ret = 0;
+       uint8_t group_id;
+       struct dla_processor_group *group;
+
+       dla_debug("Enter:%s, processor:%s\n", __func__, processor->name);
+
+       group_id = !processor->last_group;
+
+       for (j = 0; j < DLA_NUM_GROUPS; j++) {
+               group = &processor->groups[group_id];
+
+               if ((1 << DLA_EVENT_CDMA_WT_DONE) & group->events) {
+                       dla_info("Handle cdma weight done event, processor %s "
+                               "group %u\n", processor->name, group->id);
+
+                       ret = dla_update_consumers(group,
+                                                  group->op_desc,
+                                                  DLA_EVENT_CDMA_WT_DONE);
+                       if (ret)
+                               goto exit;
+               }
+
+               if ((1 << DLA_EVENT_CDMA_DT_DONE) & group->events) {
+                       dla_info("Handle cdma data done event, processor %s "
+                               "group %u\n", processor->name, group->id);
+
+                       ret = dla_update_consumers(group,
+                                                  group->op_desc,
+                                                  DLA_EVENT_CDMA_DT_DONE);
+                       if (ret)
+                               goto exit;
+               }
+
+               /*
+                * Handle complete after all other events
+                */
+               if ((1 << DLA_EVENT_OP_COMPLETED) & group->events) {
+                       dla_info("Handle op complete event, processor %s "
+                               "group %u\n", processor->name, group->id);
+
+                       ret = dla_op_completion(processor, group);
+                       if (ret)
+                               goto exit;
+               }
+
+               /*
+                * Clear all events
+                */
+               group->events = 0;
+               group_id = !group_id;
+       }
+exit:
+       dla_debug("Exit:%s, ret:%x\n", __func__, ret);
+       RETURN(ret);
+}
+
+int
+dla_process_events(void *engine_context, uint32_t *task_complete)
+{
+       int32_t i;
+       int32_t ret = 0;
+       struct dla_engine *engine = (struct dla_engine *)engine_context;
+
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               struct dla_processor *processor;
+
+               processor = &engine->processors[i];
+               ret = dla_handle_events(processor);
+               /*
+                * Incase engine status is non-zero, then don't
+                * update the engine status. We should keep its
+                * status for later cleaning of engine.
+                */
+               if (!engine->status)
+                       engine->status = ret;
+       }
+
+       if (engine->network->num_operations == engine->num_proc_hwl)
+               *task_complete = 1;
+
+       RETURN(ret);
+}
+
+/*
+ * Execute task selected by task scheduler
+ *
+ * 1. Read network configuration for the task
+ * 2. Initiate processors with head of list for same op
+ * 3. Start processing events received
+ */
+int
+dla_execute_task(void *engine_context, void *task_data, void *config_data)
+{
+       int32_t ret;
+       struct dla_engine *engine = (struct dla_engine *)engine_context;
+
+       if (engine == NULL) {
+               dla_error("engine is NULL\n");
+               ret = ERR(INVALID_INPUT);
+               goto complete;
+       }
+
+       if (engine->task == NULL) {
+               dla_error("task is NULL\n");
+               ret = ERR(INVALID_INPUT);
+               goto complete;
+       }
+
+       if (engine->task->task_data != NULL) {
+               /* We have on the fly tasks running */
+               dla_warn("Already some task in progress");
+               ret = ERR(PROCESSOR_BUSY);
+               goto complete;
+       }
+
+       engine->task->task_data = task_data;
+       engine->config_data = config_data;
+       engine->network = &network;
+       engine->num_proc_hwl = 0;
+       engine->stat_enable = 0;
+
+       LOG_EVENT(0, 0, 0, LOG_TASK_START);
+
+       ret = dla_read_network_config(engine);
+       if (ret)
+               goto complete;
+
+       dla_debug_address_info(engine->task);
+
+       /*
+        * If no operations in a task means nothing to do, NULL task
+        */
+       if (engine->network->num_operations == 0)
+               goto complete;
+
+#if STAT_ENABLE
+       if (network.stat_list_index != -1)
+               engine->stat_enable = 1;
+#endif /* STAT_ENABLE */
+
+       ret = dla_initiate_processors(engine);
+       engine->status = ret;
+
+complete:
+       LOG_EVENT(0, 0, 0, LOG_TASK_END);
+
+       RETURN(ret);
+}
+
+void
+dla_clear_task(void *engine_context)
+{
+       int32_t i, j;
+       struct dla_engine *engine = (struct dla_engine *)engine_context;
+
+       for (i = 0; i < DLA_OP_NUM; i++) {
+               struct dla_processor *processor = &engine->processors[i];
+
+               processor->roi_index = 0;
+               processor->group_status = 0;
+               processor->rdma_status = 0;
+
+               processor->tail_op = NULL;
+
+               for (j = 0; j < DLA_NUM_GROUPS; j++) {
+                       struct dla_processor_group *group =
+                                               &processor->groups[j];
+
+                       group->rdma_id = group->id;
+                       group->active = 0;
+                       group->events = 0;
+                       group->roi_index = 0;
+                       group->is_rdma_needed = 0;
+                       group->lut_index = -1;
+               }
+       }
+
+       engine->task->task_data = NULL;
+       engine->network = NULL;
+       engine->num_proc_hwl = 0;
+       engine->status = 0;
+       engine->stat_enable = 0;
+
+       dla_info("reset engine done\n");
+}

diff --git a/drivers/nvdla/sdp.c b/drivers/nvdla/sdp.c
new file mode 100644 (file)
index 0000000..4497740
--- /dev/null
+++ b/drivers/nvdla/sdp.c
@@ -0,0 +1,817 @@
+/*
+ * 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.
+ */
+
+#include <opendla.h>
+#include <dla_debug.h>
+#include <dla_interface.h>
+
+#include "common.h"
+#include "dla_engine_internal.h"
+#include "engine_debug.h"
+
+static const uint8_t map_ena[] = {
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DISABLE, YES),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DISABLE, NO),
+};
+
+static const uint8_t map_prelu[] = {
+       FIELD_ENUM(SDP_D_DP_BS_CFG_0, BS_MUL_PRELU, NO),
+       FIELD_ENUM(SDP_D_DP_BS_CFG_0, BS_MUL_PRELU, YES),
+};
+
+static const uint8_t map_bypass[] = {
+       FIELD_ENUM(SDP_D_DP_BS_CFG_0, BS_BYPASS, YES),
+       FIELD_ENUM(SDP_D_DP_BS_CFG_0, BS_BYPASS, NO),
+};
+
+static const uint8_t map_alu_op[] = {
+       FIELD_ENUM(SDP_D_DP_EW_CFG_0, EW_ALU_ALGO, MAX),
+       FIELD_ENUM(SDP_D_DP_EW_CFG_0, EW_ALU_ALGO, MIN),
+       FIELD_ENUM(SDP_D_DP_EW_CFG_0, EW_ALU_ALGO, SUM),
+       FIELD_ENUM(SDP_D_DP_EW_CFG_0, EW_ALU_ALGO, EQL),
+};
+
+static const uint8_t map_alu_src[] = {
+       FIELD_ENUM(SDP_D_DP_BS_ALU_CFG_0, BS_ALU_SRC, MEM),
+       FIELD_ENUM(SDP_D_DP_BS_ALU_CFG_0, BS_ALU_SRC, REG),
+};
+
+static const uint8_t map_fly[] = {
+       FIELD_ENUM(SDP_D_FEATURE_MODE_CFG_0, FLYING_MODE, OFF),
+       FIELD_ENUM(SDP_D_FEATURE_MODE_CFG_0, FLYING_MODE, ON),
+};
+
+static const uint8_t map_dst[] = {
+       FIELD_ENUM(SDP_D_FEATURE_MODE_CFG_0, OUTPUT_DST, MEM),
+       FIELD_ENUM(SDP_D_FEATURE_MODE_CFG_0, OUTPUT_DST, PDP),
+};
+
+
+static const uint8_t map_wg[] = {
+       FIELD_ENUM(SDP_D_FEATURE_MODE_CFG_0, WINOGRAD, OFF),
+       FIELD_ENUM(SDP_D_FEATURE_MODE_CFG_0, WINOGRAD, ON),
+};
+
+static const uint8_t map_precision[] = {
+       FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT8),
+       FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT16),
+       FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, FP16),
+};
+
+static const uint32_t map_proc_precision[3][3] = {
+       {
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT8),
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT8),
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, FP16),
+       },
+       {
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT8),
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT16),
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, FP16),
+       },
+       {
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT8),
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, INT16),
+               FIELD_ENUM(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION, FP16),
+       },
+};
+
+static const uint8_t map_op_type[] = {
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_USE, MUL),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_USE, MUL),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_USE, ALU),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_USE, BOTH),
+};
+
+static const uint8_t map_element_size[] = {
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_SIZE, ONE_BYTE),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_SIZE, TWO_BYTE),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_SIZE, TWO_BYTE),
+};
+
+static const uint8_t map_op_mode[] = {
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_MODE, PER_ELEMENT),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_MODE, PER_KERNEL),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DATA_MODE, PER_ELEMENT),
+};
+
+static const uint8_t map_ram_type[] = {
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_RAM_TYPE, MC),
+       FIELD_ENUM(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_RAM_TYPE, CV),
+};
+
+static const uint8_t map_perf_dma[] = {
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_DMA_EN, NO),
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_DMA_EN, YES),
+};
+
+static const uint8_t map_perf_lut[] = {
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_LUT_EN, NO),
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_LUT_EN, YES),
+};
+
+static const uint8_t map_perf_sat[] = {
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_SAT_EN, NO),
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_SAT_EN, YES),
+};
+
+static const uint8_t map_perf_nan_inf[] = {
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_NAN_INF_COUNT_EN, NO),
+       FIELD_ENUM(SDP_D_PERF_ENABLE_0, PERF_NAN_INF_COUNT_EN, YES),
+};
+
+#if STAT_ENABLE
+void
+dla_sdp_stat_data(struct dla_processor *processor,
+                                       struct dla_processor_group *group)
+{
+       uint64_t end_time = 0;
+       struct dla_sdp_stat_desc *sdp_stat;
+
+       sdp_stat = &processor->stat_data_desc->sdp_stat;
+
+       end_time = dla_get_time_us();
+
+       sdp_stat->nan_input_num = sdp_reg_read(D_STATUS_NAN_INPUT_NUM);
+       sdp_stat->inf_input_num = sdp_reg_read(D_STATUS_INF_INPUT_NUM);
+       sdp_stat->nan_output_num = sdp_reg_read(D_STATUS_NAN_OUTPUT_NUM);
+       sdp_stat->wdma_write_stall = sdp_reg_read(D_PERF_WDMA_WRITE_STALL);
+       sdp_stat->runtime = (uint32_t)(end_time - group->start_time);
+}
+
+void
+dla_sdp_dump_stat(struct dla_processor *processor)
+{
+       struct dla_sdp_stat_desc *sdp_stat;
+
+       sdp_stat = &processor->stat_data_desc->sdp_stat;
+
+       dla_debug_sdp_stats(sdp_stat);
+}
+#endif /* STAT_ENABLE */
+
+void
+dla_sdp_set_producer(int32_t group_id, int32_t rdma_group_id)
+{
+       uint32_t reg;
+
+       /**
+        * set producer pointer for all sub-modules
+        */
+       reg = group_id << SHIFT(SDP_S_POINTER_0, PRODUCER);
+       sdp_reg_write(S_POINTER, reg);
+       reg = rdma_group_id << SHIFT(SDP_RDMA_S_POINTER_0, PRODUCER);
+       sdp_rdma_reg_write(S_POINTER, reg);
+}
+
+int
+dla_sdp_enable(struct dla_processor_group *group)
+{
+       uint32_t reg;
+       uint8_t perf_reg;
+       struct dla_engine *engine = dla_get_engine();
+
+       dla_trace("Enter: %s", __func__);
+
+       if (engine->stat_enable == (uint32_t)1) {
+               perf_reg = (map_perf_dma[1] <<
+                       SHIFT(SDP_D_PERF_ENABLE_0, PERF_DMA_EN)) |
+                       (map_perf_lut[1] <<
+                       SHIFT(SDP_D_PERF_ENABLE_0, PERF_LUT_EN)) |
+                       (map_perf_sat[1] <<
+                       SHIFT(SDP_D_PERF_ENABLE_0, PERF_SAT_EN)) |
+                       (map_perf_nan_inf[1] <<
+                       SHIFT(SDP_D_PERF_ENABLE_0, PERF_NAN_INF_COUNT_EN));
+
+               sdp_reg_write(D_PERF_ENABLE, perf_reg);
+               group->start_time = dla_get_time_us();
+       }
+
+       /**
+        * enable all sub-modules
+        */
+       if (group->is_rdma_needed) {
+               reg = FIELD_ENUM(SDP_RDMA_D_OP_ENABLE_0, OP_EN, ENABLE);
+               sdp_rdma_reg_write(D_OP_ENABLE, reg);
+       }
+       reg = FIELD_ENUM(SDP_D_OP_ENABLE_0, OP_EN, ENABLE);
+       sdp_reg_write(D_OP_ENABLE, reg);
+
+       dla_trace("Exit: %s", __func__);
+
+       RETURN(0);
+}
+
+void
+dla_sdp_rdma_check(struct dla_processor_group *group)
+{
+       uint8_t x1_rdma_ena;
+       uint8_t x2_rdma_ena;
+       uint8_t y_rdma_ena;
+       uint8_t fly;
+       struct dla_sdp_op_desc *sdp_op;
+       struct dla_sdp_surface_desc *sdp_surface;
+
+       sdp_op = &group->operation_desc->sdp_op;
+       sdp_surface = &group->surface_desc->sdp_surface;
+
+       x1_rdma_ena = sdp_op->x1_op.enable;
+       x2_rdma_ena = sdp_op->x2_op.enable;
+       y_rdma_ena  = sdp_op->y_op.enable;
+
+       x1_rdma_ena &= (sdp_op->x1_op.mode != SDP_OP_PER_LAYER);
+       x2_rdma_ena &= (sdp_op->x2_op.mode != SDP_OP_PER_LAYER);
+       y_rdma_ena &= (sdp_op->y_op.mode != SDP_OP_PER_LAYER);
+
+       fly = sdp_surface->src_data.type == DLA_MEM_HW;
+
+       group->is_rdma_needed = (!fly) || (x1_rdma_ena ||
+                                       x2_rdma_ena || y_rdma_ena);
+}
+
+static int32_t
+processor_sdp_program(struct dla_processor_group *group)
+{
+       int32_t ret = 0;
+       uint64_t src_addr = -1, x1_addr = -1, x2_addr = -1;
+       uint64_t  y_addr = -1, dst_addr = -1;
+       uint32_t reg, high, low;
+       uint8_t fly;
+       uint32_t __maybe_unused atom_size;
+       struct dla_sdp_op *x1_op;
+       struct dla_sdp_op *x2_op;
+       struct dla_sdp_op *y_op;
+       uint8_t x1_rdma_ena;
+       uint8_t x2_rdma_ena;
+       uint8_t y_rdma_ena;
+       uint8_t out_dma_ena;
+       struct dla_lut_param lut;
+       struct dla_engine *engine = dla_get_engine();
+       struct dla_sdp_op_desc *sdp_op;
+       struct dla_sdp_surface_desc *sdp_surface;
+
+       dla_trace("Enter: %s", __func__);
+       atom_size = engine->config_data->atom_size;
+
+       sdp_op = &group->operation_desc->sdp_op;
+       sdp_surface = &group->surface_desc->sdp_surface;
+
+       fly = sdp_surface->src_data.type == DLA_MEM_HW;
+       out_dma_ena = sdp_surface->dst_data.type != DLA_MEM_HW;
+       x1_op = &sdp_op->x1_op;
+       x2_op = &sdp_op->x2_op;
+       y_op = &sdp_op->y_op;
+       x1_rdma_ena = x1_op->enable && x1_op->type != SDP_OP_NONE;
+       x2_rdma_ena = x2_op->enable && x2_op->type != SDP_OP_NONE;
+       y_rdma_ena  = y_op->enable && y_op->type != SDP_OP_NONE;
+
+       /* load address */
+       if (!fly) {
+               ret = dla_read_input_address(&sdp_surface->src_data,
+                                               &src_addr,
+                                               group->op_desc->index,
+                                               group->roi_index,
+                                           1);
+               if (ret)
+                       goto exit;
+               CHECK_ALIGN(src_addr, atom_size);
+       }
+
+       if (out_dma_ena) {
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       sdp_surface->dst_data.address,
+                                       sdp_surface->dst_data.offset,
+                                       (void *)&dst_addr,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(dst_addr, atom_size);
+       }
+
+       if (sdp_op->lut_index >= 0) {
+               group->lut_index = sdp_op->lut_index;
+               dla_read_lut(engine, sdp_op->lut_index, (void *)&lut);
+               dla_debug_lut_params(&lut);
+       }
+
+
+       x1_rdma_ena &= (x1_op->mode != SDP_OP_PER_LAYER);
+       x2_rdma_ena &= (x2_op->mode != SDP_OP_PER_LAYER);
+       y_rdma_ena &= (y_op->mode != SDP_OP_PER_LAYER);
+
+       if (x1_rdma_ena) {
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       sdp_surface->x1_data.address,
+                                       sdp_surface->x1_data.offset,
+                                       (void *)&x1_addr,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(x1_addr, atom_size);
+       }
+       if (x2_rdma_ena) {
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       sdp_surface->x2_data.address,
+                                       sdp_surface->x2_data.offset,
+                                       (void *)&x2_addr,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(x2_addr, atom_size);
+       }
+       if (y_rdma_ena) {
+               dla_get_dma_cube_address(engine->driver_context,
+                                       engine->task->task_data,
+                                       sdp_surface->y_data.address,
+                                       sdp_surface->y_data.offset,
+                                       (void *)&y_addr,
+                                       DESTINATION_DMA);
+               CHECK_ALIGN(y_addr, atom_size);
+       }
+
+       reg = (map_fly[0] << SHIFT(SDP_RDMA_D_FEATURE_MODE_CFG_0, FLYING_MODE));
+       sdp_rdma_reg_write(D_FEATURE_MODE_CFG, reg);
+
+       reg = (map_ena[1] << SHIFT(SDP_RDMA_D_BRDMA_CFG_0, BRDMA_DISABLE));
+       sdp_rdma_reg_write(D_BRDMA_CFG, reg);
+       reg = (map_ena[1] << SHIFT(SDP_RDMA_D_NRDMA_CFG_0, NRDMA_DISABLE));
+       sdp_rdma_reg_write(D_NRDMA_CFG, reg);
+       reg = (map_ena[1] << SHIFT(SDP_RDMA_D_ERDMA_CFG_0, ERDMA_DISABLE));
+       sdp_rdma_reg_write(D_ERDMA_CFG, reg);
+
+       reg = (map_fly[fly] <<
+                       SHIFT(SDP_RDMA_D_FEATURE_MODE_CFG_0, FLYING_MODE)) |
+       (map_wg[sdp_op->conv_mode == CONV_MODE_WINOGRAD] <<
+                       SHIFT(SDP_RDMA_D_FEATURE_MODE_CFG_0, WINOGRAD)) |
+       (map_precision[sdp_op->src_precision] <<
+                       SHIFT(SDP_RDMA_D_FEATURE_MODE_CFG_0, IN_PRECISION)) |
+       (map_precision[sdp_op->dst_precision] <<
+                       SHIFT(SDP_RDMA_D_FEATURE_MODE_CFG_0, OUT_PRECISION)) |
+       (map_proc_precision[sdp_op->dst_precision][sdp_op->src_precision] <<
+                       SHIFT(SDP_RDMA_D_FEATURE_MODE_CFG_0, PROC_PRECISION)) |
+       ((sdp_op->batch_num-1) <<
+                       SHIFT(SDP_RDMA_D_FEATURE_MODE_CFG_0, BATCH_NUMBER));
+       sdp_rdma_reg_write(D_FEATURE_MODE_CFG, reg);
+
+       if (group->is_rdma_needed) {
+
+               sdp_rdma_reg_write(D_DATA_CUBE_WIDTH,
+                                       sdp_surface->src_data.width - 1);
+               sdp_rdma_reg_write(D_DATA_CUBE_HEIGHT,
+                                       sdp_surface->src_data.height - 1);
+               sdp_rdma_reg_write(D_DATA_CUBE_CHANNEL,
+                                       sdp_surface->src_data.channel - 1);
+
+               /* config SDP source info */
+               if (!fly) {
+                       /**
+                        * if not on-the-fly, we have to config
+                        * the source cube info
+                        */
+                       high = HIGH32BITS(src_addr);
+                       low = LOW32BITS(src_addr);
+                       sdp_rdma_reg_write(D_SRC_BASE_ADDR_LOW, low);
+                       sdp_rdma_reg_write(D_SRC_BASE_ADDR_HIGH, high);
+                       sdp_rdma_reg_write(D_SRC_LINE_STRIDE,
+                                       sdp_surface->src_data.line_stride);
+                       sdp_rdma_reg_write(D_SRC_SURFACE_STRIDE,
+                                       sdp_surface->src_data.surf_stride);
+                       sdp_rdma_reg_write(D_SRC_DMA_CFG,
+                               map_ram_type[sdp_surface->src_data.type]);
+               }
+
+               /* config x1 source info */
+               reg = (map_ena[x1_rdma_ena] <<
+                               SHIFT(SDP_RDMA_D_BRDMA_CFG_0,
+                               BRDMA_DISABLE)) |
+                       (map_op_type[x1_op->type] <<
+                               SHIFT(SDP_RDMA_D_BRDMA_CFG_0,
+                               BRDMA_DATA_USE)) |
+                       (map_element_size[x1_op->precision] <<
+                               SHIFT(SDP_RDMA_D_BRDMA_CFG_0,
+                               BRDMA_DATA_SIZE)) |
+                       (map_op_mode[x1_op->mode] <<
+                               SHIFT(SDP_RDMA_D_BRDMA_CFG_0,
+                               BRDMA_DATA_MODE)) |
+                       (map_ram_type[sdp_surface->x1_data.type] <<
+                               SHIFT(SDP_RDMA_D_BRDMA_CFG_0,
+                               BRDMA_RAM_TYPE));
+               sdp_rdma_reg_write(D_BRDMA_CFG, reg);
+
+               if (x1_rdma_ena) {
+                       high = HIGH32BITS(x1_addr);
+                       low = LOW32BITS(x1_addr);
+                       sdp_rdma_reg_write(D_BS_BASE_ADDR_LOW,
+                                       low);
+                       sdp_rdma_reg_write(D_BS_BASE_ADDR_HIGH,
+                                       high);
+                       sdp_rdma_reg_write(D_BS_LINE_STRIDE,
+                                       sdp_surface->x1_data.line_stride);
+                       sdp_rdma_reg_write(D_BS_SURFACE_STRIDE,
+                                       sdp_surface->x1_data.surf_stride);
+               }
+
+               /* config x2 source info */
+               reg = (map_ena[x2_rdma_ena] <<
+                                       SHIFT(SDP_RDMA_D_NRDMA_CFG_0,
+                                       NRDMA_DISABLE)) |
+                       (map_op_type[x2_op->type] <<
+                                       SHIFT(SDP_RDMA_D_NRDMA_CFG_0,
+                                       NRDMA_DATA_USE)) |
+                       (map_element_size[x2_op->precision] <<
+                                       SHIFT(SDP_RDMA_D_NRDMA_CFG_0,
+                                       NRDMA_DATA_SIZE)) |
+                       (map_op_mode[x2_op->mode] <<
+                                       SHIFT(SDP_RDMA_D_NRDMA_CFG_0,
+                                       NRDMA_DATA_MODE)) |
+                       (map_ram_type[sdp_surface->x2_data.type] <<
+                                       SHIFT(SDP_RDMA_D_NRDMA_CFG_0,
+                                       NRDMA_RAM_TYPE));
+
+               sdp_rdma_reg_write(D_NRDMA_CFG, reg);
+
+               if (x2_rdma_ena) {
+                       high = HIGH32BITS(x2_addr);
+                       low = LOW32BITS(x2_addr);
+                       sdp_rdma_reg_write(D_BN_BASE_ADDR_LOW,
+                                       low);
+                       sdp_rdma_reg_write(D_BN_BASE_ADDR_HIGH,
+                                       high);
+                       sdp_rdma_reg_write(D_BN_LINE_STRIDE,
+                                       sdp_surface->x2_data.line_stride);
+                       sdp_rdma_reg_write(D_BN_SURFACE_STRIDE,
+                                       sdp_surface->x2_data.surf_stride);
+               }
+
+               /* config y source info */
+               reg = (map_ena[y_rdma_ena] <<
+                               SHIFT(SDP_RDMA_D_ERDMA_CFG_0,
+                               ERDMA_DISABLE)) |
+                       (map_op_type[y_op->type] <<
+                               SHIFT(SDP_RDMA_D_ERDMA_CFG_0,
+                               ERDMA_DATA_USE)) |
+                       (map_element_size[y_op->precision] <<
+                               SHIFT(SDP_RDMA_D_ERDMA_CFG_0,
+                               ERDMA_DATA_SIZE)) |
+                       (map_op_mode[y_op->mode] <<
+                               SHIFT(SDP_RDMA_D_ERDMA_CFG_0,
+                               ERDMA_DATA_MODE)) |
+                       (map_ram_type[sdp_surface->y_data.type] <<
+                               SHIFT(SDP_RDMA_D_ERDMA_CFG_0,
+                               ERDMA_RAM_TYPE));
+
+               sdp_rdma_reg_write(D_ERDMA_CFG, reg);
+               if (y_rdma_ena) {
+                       high = HIGH32BITS(y_addr);
+                       low = LOW32BITS(y_addr);
+                       sdp_rdma_reg_write(D_EW_BASE_ADDR_LOW,
+                                       low);
+                       sdp_rdma_reg_write(D_EW_BASE_ADDR_HIGH,
+                                       high);
+                       sdp_rdma_reg_write(D_EW_LINE_STRIDE,
+                                       sdp_surface->y_data.line_stride);
+                       sdp_rdma_reg_write(D_EW_SURFACE_STRIDE,
+                                       sdp_surface->y_data.surf_stride);
+               }
+       }
+
+       if (sdp_op->lut_index >= 0)
+               update_lut(SDP_S_LUT_ACCESS_CFG_0, &lut,
+                                       sdp_op->src_precision);
+
+       sdp_reg_write(D_DATA_CUBE_WIDTH, sdp_surface->src_data.width - 1);
+       sdp_reg_write(D_DATA_CUBE_HEIGHT, sdp_surface->src_data.height - 1);
+       sdp_reg_write(D_DATA_CUBE_CHANNEL, sdp_surface->src_data.channel - 1);
+
+       if (out_dma_ena) {
+               high = HIGH32BITS(dst_addr);
+               low = LOW32BITS(dst_addr);
+               sdp_reg_write(D_DST_BASE_ADDR_HIGH,
+                               high);
+               sdp_reg_write(D_DST_BASE_ADDR_LOW,
+                               low);
+               sdp_reg_write(D_DST_LINE_STRIDE,
+                               sdp_surface->dst_data.line_stride);
+               sdp_reg_write(D_DST_SURFACE_STRIDE,
+                               sdp_surface->dst_data.surf_stride);
+       }
+
+       /* Config BS module */
+       reg = (map_bypass[x1_op->enable] <<
+                       SHIFT(SDP_D_DP_BS_CFG_0,
+                       BS_BYPASS)) |
+               (map_bypass[x1_op->type != SDP_OP_MUL &&
+                               x1_op->type != SDP_OP_NONE] <<
+                       SHIFT(SDP_D_DP_BS_CFG_0,
+                       BS_ALU_BYPASS)) |
+               (map_alu_op[x1_op->alu_type] <<
+                       SHIFT(SDP_D_DP_BS_CFG_0,
+                       BS_ALU_ALGO)) |
+               (map_bypass[x1_op->type != SDP_OP_ADD &&
+                       x1_op->type != SDP_OP_NONE] <<
+                       SHIFT(SDP_D_DP_BS_CFG_0,
+                       BS_MUL_BYPASS)) |
+               (map_prelu[x1_op->act == ACTIVATION_PRELU]
+                       << SHIFT(SDP_D_DP_BS_CFG_0,
+                       BS_MUL_PRELU)) |
+               (map_bypass[x1_op->act == ACTIVATION_RELU] <<
+                       SHIFT(SDP_D_DP_BS_CFG_0,
+                       BS_RELU_BYPASS));
+       sdp_reg_write(D_DP_BS_CFG, reg);
+
+       if (x1_op->enable) {
+               if (x1_op->type == SDP_OP_ADD ||
+                               x1_op->type == SDP_OP_BOTH) {
+                       reg = (map_alu_src[x1_op->mode == SDP_OP_PER_LAYER] <<
+                                       SHIFT(SDP_D_DP_BS_ALU_CFG_0,
+                                       BS_ALU_SRC)) |
+                               (x1_op->shift_value <<
+                                       SHIFT(SDP_D_DP_BS_ALU_CFG_0,
+                                       BS_ALU_SHIFT_VALUE));
+                       sdp_reg_write(D_DP_BS_ALU_CFG, reg);
+               }
+
+               if (x1_op->mode == SDP_OP_PER_LAYER) {
+                       sdp_reg_write(D_DP_BS_ALU_SRC_VALUE,
+                                       x1_op->alu_operand);
+                       sdp_reg_write(D_DP_BS_MUL_SRC_VALUE,
+                                       x1_op->mul_operand);
+               }
+
+               /**
+                * MUL truncate will take effect no matter
+                * MUL is bypassed or not
+                */
+               reg = (map_alu_src[x1_op->mode == SDP_OP_PER_LAYER] <<
+                       SHIFT(SDP_D_DP_BS_MUL_CFG_0,
+                       BS_MUL_SRC)) |
+               (x1_op->truncate <<
+                       SHIFT(SDP_D_DP_BS_MUL_CFG_0,
+                       BS_MUL_SHIFT_VALUE));
+               sdp_reg_write(D_DP_BS_MUL_CFG, reg);
+       }
+
+       /* Config BN module */
+       reg = (map_bypass[x2_op->enable] <<
+                       SHIFT(SDP_D_DP_BN_CFG_0,
+                       BN_BYPASS)) |
+               (map_bypass[x2_op->type != SDP_OP_MUL &&
+                       x2_op->type != SDP_OP_NONE] <<
+                       SHIFT(SDP_D_DP_BN_CFG_0,
+                       BN_ALU_BYPASS)) |
+               (map_alu_op[x2_op->alu_type] <<
+                       SHIFT(SDP_D_DP_BN_CFG_0,
+                       BN_ALU_ALGO)) |
+               (map_bypass[x2_op->type != SDP_OP_ADD &&
+                       x2_op->type != SDP_OP_NONE] <<
+                       SHIFT(SDP_D_DP_BN_CFG_0,
+                       BN_MUL_BYPASS)) |
+               (map_prelu[x2_op->act == ACTIVATION_PRELU]
+                       << SHIFT(SDP_D_DP_BN_CFG_0,
+                       BN_MUL_PRELU)) |
+               (map_bypass[x2_op->act == ACTIVATION_RELU]
+                       << SHIFT(SDP_D_DP_BN_CFG_0,
+                       BN_RELU_BYPASS));
+       sdp_reg_write(D_DP_BN_CFG, reg);
+
+       if (x2_op->enable) {
+               if (x2_op->type == SDP_OP_ADD ||
+                       x2_op->type == SDP_OP_BOTH) {
+                       reg = (map_alu_src[x2_op->mode == SDP_OP_PER_LAYER] <<
+                                       SHIFT(SDP_D_DP_BN_ALU_CFG_0,
+                                       BN_ALU_SRC)) |
+                               (x2_op->shift_value <<
+                                       SHIFT(SDP_D_DP_BN_ALU_CFG_0,
+                                       BN_ALU_SHIFT_VALUE));
+                       sdp_reg_write(D_DP_BN_ALU_CFG, reg);
+               }
+
+               if (x2_op->mode == SDP_OP_PER_LAYER) {
+                       sdp_reg_write(D_DP_BN_ALU_SRC_VALUE,
+                                       x2_op->alu_operand);
+                       sdp_reg_write(D_DP_BN_MUL_SRC_VALUE,
+                                       x2_op->mul_operand);
+               }
+
+               reg = (map_alu_src[x2_op->mode == SDP_OP_PER_LAYER] <<
+                               SHIFT(SDP_D_DP_BN_MUL_CFG_0,
+                               BN_MUL_SRC)) |
+                       (x2_op->truncate <<
+                               SHIFT(SDP_D_DP_BN_MUL_CFG_0,
+                               BN_MUL_SHIFT_VALUE));
+               sdp_reg_write(D_DP_BN_MUL_CFG, reg);
+       }
+
+       /* Config EW module */
+       reg = (map_bypass[y_op->enable] <<
+                       SHIFT(SDP_D_DP_EW_CFG_0,
+                       EW_BYPASS)) |
+               (map_bypass[y_op->type != SDP_OP_MUL &&
+                       y_op->type != SDP_OP_NONE] <<
+                       SHIFT(SDP_D_DP_EW_CFG_0,
+                       EW_ALU_BYPASS)) |
+               (map_alu_op[y_op->alu_type] <<
+                       SHIFT(SDP_D_DP_EW_CFG_0,
+                       EW_ALU_ALGO)) |
+               (map_bypass[y_op->type != SDP_OP_ADD &&
+                       y_op->type != SDP_OP_NONE] <<
+                       SHIFT(SDP_D_DP_EW_CFG_0,
+                       EW_MUL_BYPASS)) |
+               ((map_prelu[y_op->act == ACTIVATION_PRELU]) <<
+                       SHIFT(SDP_D_DP_EW_CFG_0,
+                       EW_MUL_PRELU)) |
+               (map_bypass[y_op->act == ACTIVATION_LUT] <<
+                       SHIFT(SDP_D_DP_EW_CFG_0,
+                       EW_LUT_BYPASS));
+       sdp_reg_write(D_DP_EW_CFG, reg);
+
+       if (y_op->enable) {
+               if (y_op->type == SDP_OP_ADD || y_op->type == SDP_OP_BOTH) {
+                       reg = (map_alu_src[y_op->mode == SDP_OP_PER_LAYER] <<
+                                       SHIFT(SDP_D_DP_EW_ALU_CFG_0,
+                                       EW_ALU_SRC)) |
+                               (map_bypass[y_op->cvt.alu_cvt.enable] <<
+                                       SHIFT(SDP_D_DP_EW_ALU_CFG_0,
+                                       EW_ALU_CVT_BYPASS));
+                       sdp_reg_write(D_DP_EW_ALU_CFG, reg);
+
+                       if (y_op->mode == SDP_OP_PER_LAYER) {
+                               sdp_reg_write(D_DP_EW_ALU_SRC_VALUE,
+                                               y_op->alu_operand);
+                       } else {
+                               sdp_reg_write(D_DP_EW_ALU_CVT_OFFSET_VALUE,
+                                               y_op->cvt.alu_cvt.offset);
+                               sdp_reg_write(D_DP_EW_ALU_CVT_SCALE_VALUE,
+                                               y_op->cvt.alu_cvt.scale);
+                               sdp_reg_write(D_DP_EW_ALU_CVT_TRUNCATE_VALUE,
+                                               y_op->cvt.alu_cvt.truncate);
+                       }
+               }
+
+               if (y_op->type == SDP_OP_MUL || y_op->type == SDP_OP_BOTH) {
+                       reg = (map_alu_src[y_op->mode == SDP_OP_PER_LAYER] <<
+                                       SHIFT(SDP_D_DP_EW_MUL_CFG_0,
+                                       EW_MUL_SRC)) |
+                               (map_bypass[y_op->cvt.mul_cvt.enable] <<
+                                       SHIFT(SDP_D_DP_EW_MUL_CFG_0,
+                                       EW_MUL_CVT_BYPASS));
+                       sdp_reg_write(D_DP_EW_MUL_CFG, reg);
+
+                       if (y_op->mode == SDP_OP_PER_LAYER) {
+                               sdp_reg_write(D_DP_EW_MUL_SRC_VALUE,
+                                               y_op->mul_operand);
+                       } else {
+                               sdp_reg_write(D_DP_EW_MUL_CVT_OFFSET_VALUE,
+                                               y_op->cvt.mul_cvt.offset);
+                               sdp_reg_write(D_DP_EW_MUL_CVT_SCALE_VALUE,
+                                               y_op->cvt.mul_cvt.scale);
+                               sdp_reg_write(D_DP_EW_MUL_CVT_TRUNCATE_VALUE,
+                                               y_op->cvt.mul_cvt.truncate);
+                       }
+               }
+
+               sdp_reg_write(D_DP_EW_TRUNCATE_VALUE, y_op->truncate);
+       }
+
+       reg = (map_fly[sdp_surface->src_data.type == DLA_MEM_HW] <<
+                       SHIFT(SDP_D_FEATURE_MODE_CFG_0,
+                       FLYING_MODE)) |
+               (map_dst[sdp_surface->dst_data.type == DLA_MEM_HW] <<
+                       SHIFT(SDP_D_FEATURE_MODE_CFG_0,
+                       OUTPUT_DST)) |
+               (map_wg[sdp_op->conv_mode == CONV_MODE_WINOGRAD] <<
+                       SHIFT(SDP_D_FEATURE_MODE_CFG_0,
+                       WINOGRAD)) |
+               ((sdp_op->batch_num - 1) <<
+                       SHIFT(SDP_D_FEATURE_MODE_CFG_0,
+                       BATCH_NUMBER));
+       sdp_reg_write(D_FEATURE_MODE_CFG, reg);
+       sdp_reg_write(D_DST_DMA_CFG,
+                       map_ram_type[sdp_surface->dst_data.type]);
+       if (sdp_op->batch_num > 1)
+               sdp_reg_write(D_DST_BATCH_STRIDE, sdp_op->batch_stride);
+
+       reg =
+       (map_proc_precision[sdp_op->dst_precision][sdp_op->src_precision] <<
+                       SHIFT(SDP_D_DATA_FORMAT_0,
+                       PROC_PRECISION)) |
+               (map_precision[sdp_op->dst_precision] <<
+                       SHIFT(SDP_D_DATA_FORMAT_0,
+                       OUT_PRECISION));
+       sdp_reg_write(D_DATA_FORMAT, reg);
+       sdp_reg_write(D_CVT_OFFSET, sdp_op->out_cvt.offset);
+       sdp_reg_write(D_CVT_SCALE, sdp_op->out_cvt.scale);
+       sdp_reg_write(D_CVT_SHIFT, sdp_op->out_cvt.truncate);
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}
+
+int
+dla_sdp_is_ready(struct dla_processor *processor,
+                          struct dla_processor_group *group)
+{
+       struct dla_processor_group *next_group;
+       struct dla_sdp_op_desc *sdp_op;
+
+       sdp_op = &group->operation_desc->sdp_op;
+       next_group = &processor->groups[!group->id];
+
+       /**
+        * Single LUT is shared between two SDP groups, need to make
+        * sure that usage does not conflict. Also, LUT write
+        * access is locked when SDP sub-engine is active, so delay
+        * writing LUT when another group is active.
+        */
+
+       /**
+        * if no LUT required for current group then it can be programmed
+        * without further checks
+        */
+       if (sdp_op->lut_index == -1)
+               return 1;
+
+       /**
+        * if same LUT is used for both groups then it can be programmed
+        * without more checks. Even if another group is active and LUT
+        * is locked, it would have been programmed by another group.
+        */
+       if (next_group->lut_index == sdp_op->lut_index)
+               return 1;
+
+       /**
+        * if LUT index of another group is not -1 means some LUT is programmed,
+        * then do not program current LUT as we already know current LUT is not
+        * -1 and neither same as another group.
+        */
+       if (next_group->lut_index != -1)
+               return 0;
+
+       /**
+        * if current group needs LUT different than another group and that
+        * group is not active then program it.
+        */
+       if (!next_group->active)
+               return 1;
+
+       /**
+        * if control is here it means current group is using LUT different than
+        * another group and that group is active. Wait for another group to
+        * become idle.
+        */
+       return 0;
+}
+
+void
+dla_sdp_dump_config(struct dla_processor_group *group)
+{
+       struct dla_sdp_op_desc *sdp_op;
+       struct dla_sdp_surface_desc *sdp_surface;
+
+       sdp_surface = &group->surface_desc->sdp_surface;
+       sdp_op = &group->operation_desc->sdp_op;
+
+       dla_debug_sdp_surface_desc(sdp_surface, group->roi_index);
+       dla_debug_sdp_op_desc(sdp_op, group->roi_index);
+}
+
+int
+dla_sdp_program(struct dla_processor_group *group)
+{
+       int32_t ret;
+
+       dla_trace("Enter: %s", __func__);
+       dla_enable_intr(MASK(GLB_S_INTR_MASK_0, SDP_DONE_MASK1) |
+                       MASK(GLB_S_INTR_MASK_0, SDP_DONE_MASK0));
+
+       ret = processor_sdp_program(group);
+       if (ret)
+               goto exit;
+
+exit:
+       dla_trace("Exit: %s", __func__);
+       RETURN(ret);
+}

diff --git a/kernel/dma/coherent.c b/kernel/dma/coherent.c
index c21abc7..e3237a2 100644 (file)
--- a/kernel/dma/coherent.c
+++ b/kernel/dma/coherent.c
@@ -129,6 +129,7 @@ int dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
                _dma_release_coherent_memory(mem);
        return ret;
 }
+EXPORT_SYMBOL_GPL(dma_declare_coherent_memory);
 
 void dma_release_coherent_memory(struct device *dev)
 {