summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorLove Mansson <love.mansson@stericsson.com>2010-02-03 10:17:11 +0100
committerLove Mansson <love.mansson@stericsson.com>2010-02-03 10:17:11 +0100
commit188332723dd3f070f1545e477d2c55425a31bde2 (patch)
tree875246fea94a91a73708b41f91716235a11cf295
Initial commit linux_b2r2lib 0.1.0
Diffstat
-rw-r--r--CHANGESETS32
-rw-r--r--COMPONENT/component.xml13
-rw-r--r--COMPONENT/packaging.xml22
-rw-r--r--Makefile29
-rw-r--r--b2r2_api.c1466
-rw-r--r--b2r2_api.h1045
-rw-r--r--b2r2_driver_usr_api.h146
-rw-r--r--b2r2_global.h3606
8 files changed, 6359 insertions, 0 deletions
diff --git a/CHANGESETS b/CHANGESETS
new file mode 100644
index 0000000..bfaf951
--- /dev/null
+++ b/CHANGESETS
@@ -0,0 +1,32 @@
+------------------------------------------------------
+ SVNBRANCH CHANGESET
+------------------------------------------------------
+ Date : Tue Nov 17 09:40:08 IST 2009
+ Author: psen
+ Parent: http://codex.cro.st.com/svnroot/mmdlinux/linux_b2r2lib/trunk
+ Branch: http://codex.cro.st.com/svnroot/mmdlinux/linux_b2r2lib/branches/releases/0.0/trunk
+
+Description:
+------------
+ * updating changes to parent
+
+
+Modified Files:
+---------------
+ M COMPONENT/component.xml
+
+
+Diff command:
+-------------------------
+"svn diff --old=http://codex.cro.st.com/svnroot/mmdlinux/linux_b2r2lib/trunk@4826 --new=http://codex.cro.st.com/svnroot/mmdlinux/linux_b2r2lib/branches/releases/0.0/trunk@4832 --diff-cmd tkdiff"
+
+
+Merge command:
+-------------------------
+"svn merge http://codex.cro.st.com/svnroot/mmdlinux/linux_b2r2lib/trunk@4826 http://codex.cro.st.com/svnroot/mmdlinux/linux_b2r2lib/branches/releases/0.0/trunk@4832"
+
+Diff links to modified files:
+-----------------------------
+COMPONENT/component.xml http://codex.cro.st.com/svn/viewvc.php/linux_b2r2lib/trunk/COMPONENT/component.xml?p2=linux_b2r2lib/branches/releases/0.0/trunk/COMPONENT/component.xml&r1=4826&r2=4832&roottype=svn&root=mmdlinux&diff_format=h
+
+
diff --git a/COMPONENT/component.xml b/COMPONENT/component.xml
new file mode 100644
index 0000000..eaf39a7
--- /dev/null
+++ b/COMPONENT/component.xml
@@ -0,0 +1,13 @@
+<?xml version="0.0"?>
+<component name="linux_b2r2lib">
+ <abstract>Linux B2R2 lib</abstract>
+
+ <!-- component dependency list -->
+ <dependency name="makefiles" />
+ <dependency name="mmenv"/>
+
+ <!-- list of supported platforms -->
+ <property name="tag" value="mop500_ed-linux" />
+</component>
+
+
diff --git a/COMPONENT/packaging.xml b/COMPONENT/packaging.xml
new file mode 100644
index 0000000..f22f18c
--- /dev/null
+++ b/COMPONENT/packaging.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" ?>
+
+<packages>
+
+ <package name="bin">
+ <fileset>
+ <include name="COMPONENT/**" />
+ <include name="*.c" />
+ <include name="*.h" />
+ <include name="Makefile" />
+ <include name="lib/**" />
+
+ <exclude name="bin" />
+ <exclude name="bin/**" />
+ <exclude name="dep" />
+ <exclude name="dep/**" />
+ <exclude name="obj" />
+ <exclude name="obj/**" />
+ </fileset>
+ </package>
+
+</packages>
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..2d6d27c
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,29 @@
+# vim:syntax=make:
+# -*- Mode: Makefile -*-
+
+#WARNING COMPONENT_PATH is MANDATORY for Make.config and Make.rules
+#-------------------------------
+# Default Config
+#-------------------------------
+include $(MMROOT)/shared/makefiles/Make.config
+
+################################################################################
+# library
+
+ifeq ($(DEBUG),1)
+CPPFLAGS += -DDEBUG
+endif
+LIBOBJ = b2r2_api
+INSTALL_LIB = libst_b2r2.a
+INSTALL_HEADER = b2r2_api.h
+LIBNAME = st_b2r2
+
+todo: lib
+#-------------------------------
+# Generic Rules
+#-------------------------------
+include $(MMROOT)/shared/makefiles/Make.rules
+
+
+
+
diff --git a/b2r2_api.c b/b2r2_api.c
new file mode 100644
index 0000000..0e8b0c7
--- /dev/null
+++ b/b2r2_api.c
@@ -0,0 +1,1466 @@
+/*---------------------------------------------------------------------------*/
+/* © copyright STMicroelectronics(Wireless),2008. All rights reserved. For */
+/* information, STMicroelectronics(Wireless)reserves the right to license */
+/* this software concurrently under separate license conditions. */
+/* */
+/* This program is free software; you can redistribute it and/or modify it */
+/* under the terms of the GNU Lesser General Public License as published */
+/* by the Free Software Foundation; either version 2.1 of the License, */
+/* or (at your option)any later version. */
+/* */
+/* This program is distributed in the hope that it will be useful, but */
+/* WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See */
+/* the GNU Lesser General Public License for more details. */
+/* */
+/* You should have received a copy of the GNU Lesser General Public License */
+/* along with this program. If not, see <http://www.gnu.org/licenses/>. */
+/*---------------------------------------------------------------------------*/
+
+
+/** Include files */
+
+
+/** Linux includes */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+//#include <sys/fcntl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <linux/fb.h>
+#include <linux/kd.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <errno.h>
+
+/** Driver include file */
+
+#include "b2r2_driver_usr_api.h"
+
+/** b2r2 API file */
+
+#include "b2r2_api.h"
+#include "b2r2_global.h"
+
+static unsigned int compute_the_horizontal_scale_factor(B2R2_RECT *psrc_window, \
+ B2R2_RECT *pdst_window,int *x_out_width);
+static unsigned int compute_the_vertical_scale_factor(B2R2_RECT *psrc_window,\
+ B2R2_RECT *pdst_window);
+
+ static void configure_node_for_b2r2_op(b2r2_library *library,b2r2_configuration *config);
+
+#define DEBUG_NODE_DATA (0)
+#define DEBUG_PRINTF (0)
+#define PERFORMANCE_MEASUREMENT (1)
+
+/**
+ * It opens the b2r2 driver instance
+ * and returns NONE.
+ * @param[in] library The library instance.
+ * @return NONE
+ */
+void b2r2_library_init(b2r2_library* library)
+{
+
+ /** Open one driver instance */
+#if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+#endif
+
+ library->file_pointer=open("/dev/b2r2",O_RDWR);
+
+}
+
+/**
+ * Close the b2r2 driver instance
+ * and returns NONE.
+ * @param[in] library The library instance.
+ * @return NONE
+ */
+void b2r2_library_close(b2r2_library* library)
+{
+
+ /** Close the driver instance */
+#if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+#endif
+
+ close(library->file_pointer);
+
+}
+
+/**
+ * It allocates the kernal memory
+ * and returns NONE.
+ * @param[in] library The library instance.
+ * @param[out] memory Physical address of the kernal buffer.
+ * @return NONE
+ */
+
+void b2r2_library_allocate(b2r2_library* library,b2r2_buffer_memory* memory)
+{
+
+ b2r2_driver_memory driver_memory;
+
+#if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+#endif
+ /** Assign the size of memory */
+ driver_memory.size_of_memory=memory->size_of_memory;
+
+ /** Get the physical address of that memory */
+ ioctl(library->file_pointer,B2R2_ALLOCATE_MEMORY,&driver_memory);
+
+ memory->physical_address=driver_memory.physical_address;
+
+ /** Get the virtual address of that memory */
+ memory->logical_address= mmap (NULL,memory->size_of_memory,PROT_READ|PROT_WRITE,MAP_SHARED,
+ library->file_pointer,0);
+
+
+}
+
+/**
+ * It deallocates the kernal memory
+ * and returns NONE.
+ * @param[in] library The library instance.
+ * @param[out] memory Physical address of the kernal buffer.
+ * @return NONE
+ */
+void b2r2_library_deallocate(b2r2_library* library,b2r2_buffer_memory* memory)
+{
+
+ b2r2_driver_memory driver_memory;
+
+#if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+#endif
+
+ /** Assign the size of memory */
+ driver_memory.size_of_memory=memory->size_of_memory;
+ driver_memory.physical_address=memory->physical_address;
+
+ /** Get the physical address of that memory */
+ ioctl(library->file_pointer,B2R2_DEALLOCATE_MEMORY,&driver_memory);
+
+ /** need to remove the virtual address */
+ munmap(memory->logical_address,memory->size_of_memory);
+
+
+}
+
+
+
+
+
+void do_pixmap_pitch(b2r2_color_form color_format,unsigned short pic_width,unsigned short *pixmap_pitch)
+{
+ switch(color_format)
+ {
+ case A1:
+ *pixmap_pitch = pic_width/8;
+ if( 0!=pic_width%8)
+ {
+ *pixmap_pitch +=1;
+ }
+
+ break;
+
+ case CLUT1:
+ *pixmap_pitch = pic_width/8;
+ if( 0!=pic_width%8)
+ {
+ *pixmap_pitch +=1;
+ }
+
+ break;
+ case CLUT2:
+ *pixmap_pitch = pic_width/4;
+ if( 0!=pic_width%4)
+ {
+ *pixmap_pitch +=1;
+ }
+
+ break;
+
+ case CLUT4:
+ *pixmap_pitch = pic_width/2;
+ if( 0!=pic_width%2)
+ {
+ *pixmap_pitch +=1;
+ }
+
+ break;
+ case CLUT8:
+ *pixmap_pitch = pic_width;
+ break;
+
+ case ACLUT44:
+ *pixmap_pitch = pic_width;
+ break;
+ case ACLUT88:
+ *pixmap_pitch = pic_width*2;
+ break;
+ case A8:
+ *pixmap_pitch = pic_width;
+ break;
+ case RGB565:
+ *pixmap_pitch = pic_width*2;
+ break;
+ case ARGB4444:
+ *pixmap_pitch = pic_width*2;
+ break;
+ case ARGB1555:
+ *pixmap_pitch = pic_width*2;
+ break;
+ case ARGB8565:
+ *pixmap_pitch = pic_width*3;
+ break;
+ case RGB888:
+ *pixmap_pitch = pic_width*3;
+ break;
+ case YCBCR888:
+ *pixmap_pitch = pic_width*3;
+ break;
+ case ARGB8888:
+ *pixmap_pitch = pic_width*4;
+ break;
+ case AYCBCR8888:
+ *pixmap_pitch = pic_width*4;
+ break;
+ case YCBCR422R:
+ *pixmap_pitch = pic_width*2;
+ break;
+ case YCBCR42XMB:
+ *pixmap_pitch = pic_width;
+ break;
+ case YUV:
+ *pixmap_pitch = pic_width;
+ break;
+ case YCBCR42XMBN:
+ *pixmap_pitch = pic_width;
+ break;
+ case YCBCR42XR2B:
+ *pixmap_pitch = pic_width;
+ break;
+ }
+
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////
+
+int b2r2_library_operation_configure(b2r2_library *library,b2r2_configuration *config)
+{
+ b2r2_buffer_memory memory;
+ int no_of_nodes=1;
+
+
+ config->is_color_key_en = config->color_key.enable ? 1:0;
+ config->is_alpha_blend_en = config->alpha_blend.enable ? 1:0;
+ config->is_rect_clip_en = config->rect_clip.enable ? 1:0;
+ config->is_color_fill_en = config->color_fill.enable ? 1:0;
+ config->is_rop_ops_en = config->rop.enable ? 1:0;
+
+ if((config->is_alpha_blend_en||config->is_color_key_en||\
+ config->is_rect_clip_en||config->is_color_fill_en)&config->is_rop_ops_en)
+ {
+ //error to be defined
+ return -1;
+ }
+
+ if(config->dst_image.physical_address)
+ {
+ /*check for resize*/
+ config->is_resize=((config->src_window.width!=config->dst_window.width)|| \
+ (config->src_window.height!=config->dst_window.height))?1:0;
+
+ config->is_color_conversion = ((config->src_image.color_format == B2R2_YCBCR42XMBN) || \
+ (config->src_image.color_format == B2R2_YUV) || \
+ (config->src_image.color_format == B2R2_YCBCR888) || \
+ (config->src_image.color_format == B2R2_YCBCR422R) || \
+ (config->src_image.color_format == B2R2_AYCBCR8888) || \
+ (config->src_image.color_format == B2R2_YCBCR42XMB) || \
+ (config->src_image.color_format == B2R2_YCBCR42XR2B))?1:0;
+
+ config->is_rotation =(config->rotation!=B2R2_ROT_0)?1:0;
+
+ /*resize or rotation*/
+ if(config->is_resize || config->is_rotation || config->is_color_conversion)
+ {
+ /* Find the Number of nodes*/
+
+ if(config->is_rotation)
+ {
+ unsigned char is_src_width_multiple_of_16=1;
+
+ no_of_nodes = (config->rotation!=B2R2_ROT_180)?(config->src_window.width/16):1;
+ if(config->src_window.width%16)
+ {
+ no_of_nodes++;
+ is_src_width_multiple_of_16 =0;
+ }
+ /** We have to allocate memory for nodes */
+ memory.size_of_memory=no_of_nodes*sizeof(b2r2_link_list);
+ b2r2_library_allocate(library,&memory);
+ configure_rotate(no_of_nodes,is_src_width_multiple_of_16,&memory,config);
+ config->NodeAdress=memory.logical_address;
+ config->no_of_nodes =no_of_nodes;
+ config->last_nodeAdress =config->NodeAdress+(no_of_nodes-1)*sizeof(b2r2_link_list);
+ config->NodePhysicalAdress=memory.physical_address;
+ #if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+ printf("no_of_nodes is %x \n",no_of_nodes);
+ printf("config->NodephyAdress is %x \n",memory.physical_address);
+ #endif
+
+
+ }
+
+ else
+ {
+ /** resize/color conversion*/
+ unsigned char is_src_width_multiple_of_128=1;
+ //printf("config->src_window.width:%d\n",config->src_window.width);
+ no_of_nodes = (config->src_window.width/128);
+ if(config->src_window.width%128)
+ {
+ no_of_nodes++;
+ is_src_width_multiple_of_128 =0;
+ }
+ /** We have to allocate memory for nodes */
+ memory.size_of_memory=no_of_nodes*sizeof(b2r2_link_list);
+ b2r2_library_allocate(library,&memory);
+ //printf("memory.physical_address:%x\n",memory.physical_address);
+ if (config->is_color_conversion)
+ configure_color_conversion(no_of_nodes,is_src_width_multiple_of_128,&memory,config);
+ else if (config->is_resize )
+ configure_resize(no_of_nodes,is_src_width_multiple_of_128,&memory,config);
+ config->NodeAdress=memory.logical_address;
+ config->no_of_nodes =no_of_nodes;
+ config->last_nodeAdress =config->NodeAdress+(no_of_nodes-1)*sizeof(b2r2_link_list);
+ config->NodePhysicalAdress=memory.physical_address;
+ #if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+ printf("no_of_nodes is %x \n",no_of_nodes);
+ printf("config->NodephyAdress is %x \n",memory.physical_address);
+ #endif
+
+ }
+ }
+ else
+ {
+
+ /** We have to allocate memory for a node */
+
+ memory.size_of_memory=sizeof(b2r2_link_list);
+ b2r2_library_allocate(library,&memory);
+ config->NodeAdress=memory.logical_address;
+ config->no_of_nodes =1;
+ config->last_nodeAdress =config->NodeAdress;
+ config->NodePhysicalAdress=memory.physical_address;
+ configure_node_for_b2r2_op(library,config);
+ }
+ }
+ else
+ {
+ memory.size_of_memory=sizeof(b2r2_link_list);
+ b2r2_library_allocate(library,&memory);
+ config->NodeAdress=memory.logical_address;
+ config->no_of_nodes =1;
+ config->last_nodeAdress =config->NodeAdress;
+ config->NodePhysicalAdress=memory.physical_address;
+ configure_node_for_b2r2_op(library,config);
+ }
+
+ config->job.job_logical_address=memory.logical_address;
+ config->job.job_physical_address=memory.physical_address;
+ config->job.job_size=no_of_nodes*sizeof(b2r2_link_list);
+ config->job.job_pace_lna_physical_address=memory.physical_address+(no_of_nodes-1)*sizeof(b2r2_link_list);
+
+ return 0;
+}
+
+void b2r2_library_update_params(b2r2_library *library,b2r2_configuration *config,
+ B2R2_UPDATE_PARAMS params,B2R2_UPDATE_PARAMS_VAL *pVal)
+{
+ b2r2_link_list *pt_mem;
+ unsigned short pixmap_pitch;
+ int i = 0;
+
+ pt_mem=(b2r2_link_list*)(config->NodeAdress);
+
+ switch(params)
+ {
+ case B2R2_FILL_COLOR_OP_PARAMS:
+ pt_mem->GROUP2.B2R2_S1CF = pVal->val;
+ pt_mem->GROUP1.B2R2_TXY = (pVal->window_params.src_window.top<<B2R2_Y_SHIFT|pVal->window_params.src_window.left);
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(pVal->window_params.src_window.width)|(pVal->window_params.src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+ break;
+
+ case B2R2_ALPHA_BLEND_OP_PARAMS:
+ pt_mem->GROUP1.B2R2_TXY = (pVal->window_params.dst_window.top<<B2R2_Y_SHIFT|(pVal->window_params.dst_window.left));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(pVal->window_params.dst_window.width)|(pVal->window_params.dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+ pt_mem->GROUP3.B2R2_SXY = pt_mem->GROUP1.B2R2_TXY;
+ pt_mem->GROUP3.B2R2_SSZ = pt_mem->GROUP1.B2R2_TSZ;
+ pt_mem->GROUP4.B2R2_SXY = (pVal->window_params.src_window.top<<B2R2_Y_SHIFT|(pVal->window_params.src_window.left));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|(pVal->window_params.src_window.width)|(pVal->window_params.src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+ pt_mem->GROUP0.B2R2_ACK = ((pt_mem->GROUP0.B2R2_ACK & 0xffff00ff) | (pVal->val<<B2R2BLT_ACKGALPHA_ROPIDShift));
+ break;
+
+ case B2R2_COLOR_KEY_OP_PARMS:
+ pt_mem->GROUP1.B2R2_TXY = (pVal->window_params.dst_window.top<<B2R2_Y_SHIFT|(pVal->window_params.dst_window.left));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(pVal->window_params.dst_window.width)|(pVal->window_params.dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+ pt_mem->GROUP3.B2R2_SXY = pt_mem->GROUP1.B2R2_TXY;
+ pt_mem->GROUP3.B2R2_SSZ = pt_mem->GROUP1.B2R2_TSZ;
+ pt_mem->GROUP4.B2R2_SXY = (pVal->window_params.src_window.top<<B2R2_Y_SHIFT|(pVal->window_params.src_window.left));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|(pVal->window_params.src_window.width)|(pVal->window_params.src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+ pt_mem->GROUP12.B2R2_KEY1 =
+ ((((pVal->val&0xFF000000)>>24)<<B2R2BLT_KEY1ALPHA0Shift)| \
+ ((((pVal->val&0xF800)>>11)<<3)<<B2R2BLT_KEY1RED_MINShift)| \
+ ((((pVal->val&0x07E0)>>5)<<2)<<B2R2BLT_KEY1GREEN_MINShift)| \
+ ((pVal->val&0x1F)<<3));
+ pt_mem->GROUP12.B2R2_KEY2 =
+ ((((pVal->val&0xFF000000)>>24)<<B2R2BLT_KEY1ALPHA0Shift)| \
+ (((((pVal->val&0xF800)>>11)<<3)|0x7)<<B2R2BLT_KEY1RED_MINShift)| \
+ (((((pVal->val&0x07E0)>>5)<<2)|0x3)<<B2R2BLT_KEY1GREEN_MINShift)| \
+ (((pVal->val&0x1F)<<3)|0x7));
+ break;
+
+ case B2R2_ROTATION_OP_PARAMS:
+ break;
+
+ case B2R2_CLIP_OP_PARAMS:
+ pt_mem->GROUP6.B2R2_CWO =((pVal->window_params.clip_window.top<<B2R2BLT_CWOYDOShift)| \
+ pVal->window_params.clip_window.left);
+ pt_mem->GROUP6.B2R2_CWS =(((pVal->window_params.clip_window.top+pVal->window_params.clip_window.height)<<B2R2BLT_CWSYDSShift)| \
+ (pVal->window_params.clip_window.left+pVal->window_params.clip_window.width));
+ break;
+
+ case B2R2_RESIZE_OP_PARAMS:
+ break;
+
+ case B2R2_ROP_OP_PARAMS:
+ pt_mem->GROUP0.B2R2_ACK =((pt_mem->GROUP0.B2R2_ACK & 0xffff00ff) | (pVal->val<<B2R2BLT_ACKGALPHA_ROPIDShift));
+ break;
+ case B2R2_COLOR_CONVERSION_OF_PARAMS:
+ for (i=0; i < config->no_of_nodes; i++)
+ {
+ pt_mem = (b2r2_link_list*)(config->NodeAdress+(i*sizeof(b2r2_link_list)));
+ if (pVal->val == B2R2_YCBCR42XMBN)
+ {
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = 0;
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = pVal->ppp_params.source_chroma_address;
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = pVal->ppp_params.source_luma_address;
+ }
+ else if (pVal->val == B2R2_YUV)
+ {
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = pVal->ppp_params.source_chroma2_address;
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = pVal->ppp_params.source_chroma_address;
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = pVal->ppp_params.source_luma_address;
+
+}
+ }
+ break;
+ case B2R2_SOURCE_ADDRESS_OF_PARAMS:
+ if(config->is_alpha_blend_en || config->is_color_key_en || \
+ config->is_rect_clip_en || config->is_color_fill_en || config->is_rop_ops_en)
+ pt_mem->GROUP3.B2R2_SBA = pVal->val;
+ break;
+ case B2R2_DESTINATION_ADDRESS_OF_PARAMS:
+ if(config->is_alpha_blend_en || config->is_color_key_en || \
+ config->is_rect_clip_en || config->is_color_fill_en || config->is_rop_ops_en)
+ {
+ pt_mem->GROUP1.B2R2_TBA = pVal->val;
+ }
+ else if(config->is_resize || config->is_rotation || config->is_color_conversion)
+ {
+ for (i=0; i < config->no_of_nodes; i++)
+ {
+ pt_mem = (b2r2_link_list*)(config->NodeAdress+(i*sizeof(b2r2_link_list)));
+ pt_mem->GROUP1.B2R2_TBA = pVal->val;
+ }
+ }
+ break;
+ default:
+ printf("Inavlid params to update\n");
+
+ }
+}
+
+void b2r2_library_do_operation(b2r2_library *library,b2r2_configuration *config)
+{
+ b2r2_driver driver_handler;
+
+ #if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+ #endif
+
+ switch(config->job.priority)
+ {
+
+
+ case B2R2_PRIORITY_1:
+ {
+ driver_handler.context=B2R2_CQ1_JOB;
+ driver_handler.queue_address=config->job.job_physical_address;
+ //driver_handler.control=(B2R2_AQ_Enab | B2R2_AQ_PRIOR_1);
+ driver_handler.pace_control=config->job.job_pace_lna_physical_address;
+ driver_handler.interrupt_target=0;
+ driver_handler.interrupt_context=(B2R2BLT_ITSCQ1_completed);
+ }
+
+ break;
+
+ case B2R2_PRIORITY_2:
+ {
+ driver_handler.context=B2R2_CQ2_JOB;
+ driver_handler.queue_address=config->job.job_physical_address;
+ //driver_handler.control=(B2R2_AQ_Enab | B2R2_AQ_PRIOR_1);
+ driver_handler.pace_control=config->job.job_pace_lna_physical_address;
+ driver_handler.interrupt_target=0;
+ driver_handler.interrupt_context=(B2R2BLT_ITSCQ2_completed);
+ }
+
+ break;
+
+
+ case B2R2_PRIORITY_3:
+ {
+ driver_handler.context=B2R2_AQ1_JOB;
+ driver_handler.queue_address=config->job.job_physical_address;
+ driver_handler.control=(B2R2_AQ_Enab | B2R2_AQ_PRIOR_0);
+ driver_handler.pace_control=config->job.job_pace_lna_physical_address;
+ driver_handler.interrupt_target=0;
+ driver_handler.interrupt_context=(B2R2BLT_ITSAQ1_LNA_Reached)|(B2R2BLT_ITSAQ1_Node_Notif);
+ }
+
+ break;
+
+ case B2R2_PRIORITY_4:
+ {
+ driver_handler.context=B2R2_AQ2_JOB;
+ driver_handler.queue_address=config->job.job_physical_address;
+ driver_handler.control=(B2R2_AQ_Enab | B2R2_AQ_PRIOR_1);
+ driver_handler.pace_control=config->job.job_pace_lna_physical_address;
+ driver_handler.interrupt_target=0;
+ driver_handler.interrupt_context=(B2R2BLT_ITSAQ2_LNA_Reached)|(B2R2BLT_ITSAQ2_Node_Notif);
+ }
+
+ break;
+
+ case B2R2_PRIORITY_5:
+ {
+ driver_handler.context=B2R2_AQ3_JOB;
+ driver_handler.queue_address=config->job.job_physical_address;
+ driver_handler.control=(B2R2_AQ_Enab | B2R2_AQ_PRIOR_2);
+ driver_handler.pace_control=config->job.job_pace_lna_physical_address;
+ driver_handler.interrupt_target=0;
+ driver_handler.interrupt_context=(B2R2BLT_ITSAQ3_LNA_Reached)|(B2R2BLT_ITSAQ3_Node_Notif);
+ }
+
+ break;
+
+ case B2R2_PRIORITY_6:
+ {
+ driver_handler.context=B2R2_AQ4_JOB;
+ driver_handler.queue_address=config->job.job_physical_address;
+ driver_handler.control=(B2R2_AQ_Enab | B2R2_AQ_PRIOR_3);
+ driver_handler.pace_control=config->job.job_pace_lna_physical_address;
+ driver_handler.interrupt_target=0;
+ driver_handler.interrupt_context=(B2R2BLT_ITSAQ4_LNA_Reached)|(B2R2BLT_ITSAQ4_Node_Notif);
+ }
+
+ break;
+ }
+
+ /** do a queue call */
+
+ ioctl(library->file_pointer,B2R2_QUEUE_JOB,&driver_handler);
+
+ /** get the job id */
+
+ config->job.jobid=driver_handler.jobid;
+
+ #if DEBUG_NODE_DATA
+ debug_print_node_data(config->NodeAdress,5*sizeof(b2r2_link_list));
+ #endif
+
+}
+
+void b2r2_library_operation_done(b2r2_library *library,b2r2_configuration *config)
+{
+ b2r2_driver driver_handler;
+
+#if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+#endif
+ /** get the job queue id */
+
+ driver_handler.jobid=config->job.jobid;
+ driver_handler.context=B2R2_AQ1_JOB;
+
+ /** do a dequeue call */
+
+ ioctl(library->file_pointer,B2R2_DEQUEUE_JOB,&driver_handler);
+}
+
+void configure_resize(unsigned char no_of_nodes,unsigned char is_src_width_multiple_of_128,\
+ b2r2_buffer_memory *pNode_mem,b2r2_configuration *config)
+{
+ b2r2_link_list *pt_mem;
+ int i=0;
+ unsigned short dst_pixmap_pitch,src_pixmap_pitch;
+ B2R2_RECT src_rsz_inc_rect,dst_rsz_inc_vect;
+ int x_in_offset=0,x_out_offset=0;
+ int x_in_width=128,x_out_width=0;
+ unsigned char no_of_nodes_multiple_of_128=0;
+ unsigned int chroma_rsf=0,luma_rsf=0;
+
+ no_of_nodes_multiple_of_128=(is_src_width_multiple_of_128)? \
+ no_of_nodes:no_of_nodes-1;
+
+ pt_mem= (b2r2_link_list*)(pNode_mem->logical_address);
+ do_pixmap_pitch(config->dst_image.color_format,config->dst_image.width,&dst_pixmap_pitch);
+ do_pixmap_pitch(config->src_image.color_format,config->src_image.width,&src_pixmap_pitch);
+
+ /*For the nodes whose source width is equal to 128*/
+
+ if(config->src_window.width!=config->dst_window.width)
+ {
+ chroma_rsf=compute_the_horizontal_scale_factor(&config->src_window,&config->dst_window,&x_out_width);
+
+ if(x_out_width == 0)
+ {
+ printf("xoutwidth = %d, \n",x_out_width);
+ while(1);
+ }
+ }
+ else
+ {
+ chroma_rsf=0x0400;
+ x_out_width =128;
+ }
+
+ if(config->src_window.height!=config->dst_window.height)
+ {
+ luma_rsf=compute_the_vertical_scale_factor(&config->src_window,&config->dst_window);
+ }
+ else
+ {
+ luma_rsf=0x0400;
+ }
+
+ for(i=0;i<no_of_nodes_multiple_of_128;i++)
+ {
+ pt_mem->GROUP0.B2R2_NIP = pNode_mem->physical_address+(i+1)*sizeof(b2r2_link_list);
+ pt_mem->GROUP0.B2R2_CIC = 0x1FFF;
+ pt_mem->GROUP0.B2R2_INS = (B2R2_SRC2_FETCH_MEM|B2R2BLT_INS2DRESCALE);
+ pt_mem->GROUP0.B2R2_ACK = B2R2_BYPASS_SRC2_SRC3;
+
+ pt_mem->GROUP1.B2R2_TBA = config->dst_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|dst_pixmap_pitch);
+ pt_mem->GROUP1.B2R2_TXY = (config->dst_window.top<<B2R2_Y_SHIFT|(config->dst_window.left+x_out_offset));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|x_out_width|(config->dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ pt_mem->GROUP2.B2R2_S1CF = 0;
+ pt_mem->GROUP2.B2R2_S2CF = 0;
+
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = 0;
+ pt_mem->GROUP3.B2R2_STY = 0;
+ pt_mem->GROUP3.B2R2_SXY = 0;
+ pt_mem->GROUP3.B2R2_SSZ = 0;
+
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = config->src_image.physical_address;
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ pt_mem->GROUP4.B2R2_SXY = (config->src_window.top<<B2R2_Y_SHIFT|(config->src_window.left+x_in_offset));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|x_in_width|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ //printf("iteration= %d,Node addrress is %x \n",i,pt_mem);
+
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = 0;
+ pt_mem->GROUP5.B2R2_STY = 0;
+ pt_mem->GROUP5.B2R2_SXY = 0;
+ pt_mem->GROUP5.B2R2_SSZ = 0;
+
+ /*Clip*/
+ pt_mem->GROUP6.B2R2_CWO = 0;
+ pt_mem->GROUP6.B2R2_CWS = 0;
+
+ /*Clut*/
+ pt_mem->GROUP7.B2R2_CCO = 0;
+ pt_mem->GROUP7.B2R2_CML = 0;
+
+ pt_mem->GROUP8.B2R2_FCTL=0x22000044;
+ pt_mem->GROUP8.B2R2_PMK =0;
+
+ pt_mem->GROUP9.B2R2_RSF=((luma_rsf<<16)|chroma_rsf);//0x08000800;
+ pt_mem->GROUP9.B2R2_RZI=0x30003000;
+ pt_mem->GROUP9.B2R2_HFP=0;
+ pt_mem->GROUP9.B2R2_VFP=0;
+
+ pt_mem->GROUP10.B2R2_RSF=((luma_rsf<<16)|chroma_rsf);//0x08000800;
+ pt_mem->GROUP10.B2R2_RZI=0x30003000;
+ pt_mem->GROUP10.B2R2_HFP=0;
+ pt_mem->GROUP10.B2R2_VFP=0;
+
+ pt_mem->GROUP12.B2R2_KEY1=0;
+ pt_mem->GROUP12.B2R2_KEY2=0;
+
+ x_in_offset+=128;
+ x_out_offset+=x_out_width;
+
+
+ if((i==no_of_nodes_multiple_of_128-1)&&(is_src_width_multiple_of_128))
+ {
+ pt_mem->GROUP0.B2R2_NIP= 0;
+ pt_mem->GROUP0.B2R2_INS |=B2R2BLT_INSBlitCompIRQ ;
+ }
+ else
+ {
+ pt_mem++;
+ }
+ }
+
+ /*For the node whose source width less than 128*/
+ if(is_src_width_multiple_of_128==0)
+ {
+ pt_mem->GROUP0.B2R2_NIP= 0;
+
+ pt_mem->GROUP0.B2R2_CIC = 0x1FFF;
+ pt_mem->GROUP0.B2R2_INS = (B2R2_SRC2_FETCH_MEM|B2R2BLT_INS2DRESCALE|B2R2BLT_INSBlitCompIRQ);
+ pt_mem->GROUP0.B2R2_ACK = B2R2_BYPASS_SRC2_SRC3;
+
+ pt_mem->GROUP1.B2R2_TBA = config->dst_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|dst_pixmap_pitch);
+ pt_mem->GROUP1.B2R2_TXY = (config->dst_window.top<<B2R2_Y_SHIFT|(config->dst_window.left+x_out_offset));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(config->dst_window.width-x_out_offset)|(config->dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ pt_mem->GROUP2.B2R2_S1CF = 0;
+ pt_mem->GROUP2.B2R2_S2CF = 0;
+
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = 0;
+ pt_mem->GROUP3.B2R2_STY = 0;
+ pt_mem->GROUP3.B2R2_SXY = 0;
+ pt_mem->GROUP3.B2R2_SSZ = 0;
+
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = config->src_image.physical_address;
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ pt_mem->GROUP4.B2R2_SXY = (config->src_window.top<<B2R2_Y_SHIFT|(config->src_window.left+x_in_offset));;
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|(config->src_window.width-x_in_offset)|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = 0;
+ pt_mem->GROUP5.B2R2_STY = 0;
+ pt_mem->GROUP5.B2R2_SXY = 0;
+ pt_mem->GROUP5.B2R2_SSZ = 0;
+
+ /*Clip*/
+ pt_mem->GROUP6.B2R2_CWO = 0;
+ pt_mem->GROUP6.B2R2_CWS = 0;
+
+ /*Clut*/
+ pt_mem->GROUP7.B2R2_CCO = 0;
+ pt_mem->GROUP7.B2R2_CML = 0;
+
+ pt_mem->GROUP8.B2R2_FCTL=0x22000044;
+ pt_mem->GROUP8.B2R2_PMK =0;
+
+ pt_mem->GROUP9.B2R2_RSF=((luma_rsf<<16)|chroma_rsf);
+ pt_mem->GROUP9.B2R2_RZI=0x30003000;
+ pt_mem->GROUP9.B2R2_HFP=0;
+ pt_mem->GROUP9.B2R2_VFP=0;
+
+ pt_mem->GROUP10.B2R2_RSF=((luma_rsf<<16)|chroma_rsf);
+ pt_mem->GROUP10.B2R2_RZI=0x30003000;
+ pt_mem->GROUP10.B2R2_HFP=0;
+ pt_mem->GROUP10.B2R2_VFP=0;
+
+ pt_mem->GROUP12.B2R2_KEY1=0;
+ pt_mem->GROUP12.B2R2_KEY2=0;
+
+ }
+
+}
+
+
+
+void configure_rotate(unsigned char no_of_nodes,unsigned char is_src_width_multiple_of_16,\
+ b2r2_buffer_memory *pNode_mem,b2r2_configuration *config)
+{
+ b2r2_link_list *pt_mem;
+ int i=0;
+ unsigned short dst_pixmap_pitch,src_pixmap_pitch;
+ B2R2_RECT src_rsz_inc_rect,dst_rsz_inc_vect;
+ int x_in_offset=0,x_out_offset=0;
+ int x_in_width=16,x_out_width=16;
+ unsigned char no_of_nodes_multiple_of_16=0;
+ unsigned int chroma_rsf=0,luma_rsf=0;
+
+ no_of_nodes_multiple_of_16=(is_src_width_multiple_of_16)? \
+ no_of_nodes:no_of_nodes-1;
+
+ if(config->rotation == B2R2_ROT_180)
+ {
+ no_of_nodes_multiple_of_16=1;
+ is_src_width_multiple_of_16=1;
+
+ if(config->src_window.width<16)
+ is_src_width_multiple_of_16=0;
+ }
+
+
+
+ pt_mem= (b2r2_link_list*)(pNode_mem->logical_address);
+
+ do_pixmap_pitch(config->dst_image.color_format,config->dst_image.width,&dst_pixmap_pitch);
+ do_pixmap_pitch(config->src_image.color_format,config->src_image.width,&src_pixmap_pitch);
+
+ for(i=0;i<no_of_nodes_multiple_of_16;i++)
+ {
+ pt_mem->GROUP0.B2R2_NIP = pNode_mem->physical_address+(i+1)*sizeof(b2r2_link_list);
+ pt_mem->GROUP0.B2R2_CIC = 0x1FFF;
+ pt_mem->GROUP0.B2R2_INS = (B2R2_SRC2_FETCH_MEM);
+ pt_mem->GROUP0.B2R2_ACK = B2R2_BYPASS_SRC2_SRC3;
+
+ pt_mem->GROUP1.B2R2_TBA = config->dst_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|dst_pixmap_pitch);
+
+
+ pt_mem->GROUP2.B2R2_S1CF = 0;
+ pt_mem->GROUP2.B2R2_S2CF = 0;
+
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = 0;
+ pt_mem->GROUP3.B2R2_STY = 0;
+ pt_mem->GROUP3.B2R2_SXY = 0;
+ pt_mem->GROUP3.B2R2_SSZ = 0;
+
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = config->src_image.physical_address;
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ pt_mem->GROUP4.B2R2_SXY = (config->src_window.top<<B2R2_Y_SHIFT|(config->src_window.left+x_in_offset));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|x_in_width|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ //printf("iteration= %d,Node addrress is %x \n",i,pt_mem);
+
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = 0;
+ pt_mem->GROUP5.B2R2_STY = 0;
+ pt_mem->GROUP5.B2R2_SXY = 0;
+ pt_mem->GROUP5.B2R2_SSZ = 0;
+
+ /*Clip*/
+ pt_mem->GROUP6.B2R2_CWO = 0;
+ pt_mem->GROUP6.B2R2_CWS = 0;
+
+ /*Clut*/
+ pt_mem->GROUP7.B2R2_CCO = 0;
+ pt_mem->GROUP7.B2R2_CML = 0;
+
+ pt_mem->GROUP8.B2R2_FCTL=0;
+ pt_mem->GROUP8.B2R2_PMK =0;
+
+ pt_mem->GROUP9.B2R2_RSF=0;
+ pt_mem->GROUP9.B2R2_RZI=0;
+ pt_mem->GROUP9.B2R2_HFP=0;
+ pt_mem->GROUP9.B2R2_VFP=0;
+
+ pt_mem->GROUP10.B2R2_RSF=0;
+ pt_mem->GROUP10.B2R2_RZI=0;
+ pt_mem->GROUP10.B2R2_HFP=0;
+ pt_mem->GROUP10.B2R2_VFP=0;
+
+ pt_mem->GROUP12.B2R2_KEY1=0;
+ pt_mem->GROUP12.B2R2_KEY2=0;
+
+
+ if(config->rotation== B2R2_ROT_90)
+ { /** Set rotation enabled bit */
+ pt_mem->GROUP0.B2R2_INS |= B2R2BLT_INSROTATION;
+ pt_mem->GROUP1.B2R2_TTY |= (B2R2BLT_TTYHSO); //Set this bit to start line write operation from bottom to top in target area
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(x_out_width<<B2R2BLT_TSZWIN_HEIGHTShift)|config->src_window.height);
+ pt_mem->GROUP1.B2R2_TXY = ((((config->dst_window.top)+x_out_width*i)<<B2R2_Y_SHIFT)|(config->dst_window.left+config->dst_window.width-1));
+
+ }
+
+ if(config->rotation == B2R2_ROT_180)
+ {
+ pt_mem->GROUP1.B2R2_TTY |= (B2R2BLT_TTYVSO|B2R2BLT_TTYHSO);
+ pt_mem->GROUP1.B2R2_TXY = (((config->dst_window.top+config->dst_window.height-1)<<B2R2_Y_SHIFT)|(config->dst_window.left+config->dst_window.width-1));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|config->dst_window.width|(config->dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|config->src_window.width|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+
+ }
+
+ if(config->rotation == B2R2_ROT_270)
+ {
+ pt_mem->GROUP0.B2R2_INS |= B2R2BLT_INSROTATION;
+ pt_mem->GROUP1.B2R2_TTY |= (B2R2BLT_TTYVSO); //Set this bit to start pixel write operation from right to left in target area
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(x_out_width<<B2R2BLT_TSZWIN_HEIGHTShift)|config->src_window.height);
+ pt_mem->GROUP1.B2R2_TXY = ((config->dst_window.top)+(config->dst_window.height-1)-(x_out_width*i))<<B2R2_Y_SHIFT|config->dst_window.left;
+
+ }
+
+ x_in_offset+=16;
+ x_out_offset+=16;
+
+
+ if((i==no_of_nodes_multiple_of_16-1)&&(is_src_width_multiple_of_16))
+ {
+ pt_mem->GROUP0.B2R2_NIP= 0;
+ pt_mem->GROUP0.B2R2_INS |=B2R2BLT_INSBlitCompIRQ ;
+ }
+ else
+ {
+ pt_mem++;
+ }
+ }
+
+
+ /*For the node whose source width less than 128*/
+ if(is_src_width_multiple_of_16==0)
+ {
+
+ x_in_width=config->src_window.width-no_of_nodes_multiple_of_16*16;
+ x_out_width=x_in_width;
+
+ pt_mem->GROUP0.B2R2_NIP= 0;
+
+ pt_mem->GROUP0.B2R2_CIC = 0x1FFF;
+ pt_mem->GROUP0.B2R2_INS = (B2R2_SRC2_FETCH_MEM);
+ pt_mem->GROUP0.B2R2_ACK = B2R2_BYPASS_SRC2_SRC3;
+
+ pt_mem->GROUP1.B2R2_TBA = config->dst_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|dst_pixmap_pitch);
+
+
+ pt_mem->GROUP2.B2R2_S1CF = 0;
+ pt_mem->GROUP2.B2R2_S2CF = 0;
+
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = 0;
+ pt_mem->GROUP3.B2R2_STY = 0;
+ pt_mem->GROUP3.B2R2_SXY = 0;
+ pt_mem->GROUP3.B2R2_SSZ = 0;
+
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = config->src_image.physical_address;
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ pt_mem->GROUP4.B2R2_SXY = (config->src_window.top<<B2R2_Y_SHIFT|(config->src_window.left+x_in_offset));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|x_in_width|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = 0;
+ pt_mem->GROUP5.B2R2_STY = 0;
+ pt_mem->GROUP5.B2R2_SXY = 0;
+ pt_mem->GROUP5.B2R2_SSZ = 0;
+
+ /*Clip*/
+ pt_mem->GROUP6.B2R2_CWO = 0;
+ pt_mem->GROUP6.B2R2_CWS = 0;
+
+ /*Clut*/
+ pt_mem->GROUP7.B2R2_CCO = 0;
+ pt_mem->GROUP7.B2R2_CML = 0;
+
+ pt_mem->GROUP8.B2R2_FCTL=0;
+ pt_mem->GROUP8.B2R2_PMK =0;
+
+ pt_mem->GROUP9.B2R2_RSF=0;
+ pt_mem->GROUP9.B2R2_RZI=0;
+ pt_mem->GROUP9.B2R2_HFP=0;
+ pt_mem->GROUP9.B2R2_VFP=0;
+
+ pt_mem->GROUP10.B2R2_RSF=0;
+ pt_mem->GROUP10.B2R2_RZI=0;
+ pt_mem->GROUP10.B2R2_HFP=0;
+ pt_mem->GROUP10.B2R2_VFP=0;
+
+ pt_mem->GROUP12.B2R2_KEY1=0;
+ pt_mem->GROUP12.B2R2_KEY2=0;
+
+
+ if(config->rotation== B2R2_ROT_90)
+ { /** Set rotation enabled bit */
+ pt_mem->GROUP0.B2R2_INS |= B2R2BLT_INSROTATION;
+ pt_mem->GROUP1.B2R2_TTY |= (B2R2BLT_TTYHSO); //Set this bit to start line write operation from bottom to top in target area
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(x_out_width<<B2R2BLT_TSZWIN_HEIGHTShift)|config->src_window.height);
+ pt_mem->GROUP1.B2R2_TXY = ((((config->dst_window.top)+x_out_width*i)<<B2R2_Y_SHIFT)|(config->dst_window.left+config->dst_window.width-1));
+
+ }
+
+ if(config->rotation == B2R2_ROT_270)
+ {
+ pt_mem->GROUP0.B2R2_INS |= B2R2BLT_INSROTATION;
+ pt_mem->GROUP1.B2R2_TTY |= (B2R2BLT_TTYVSO); //Set this bit to start pixel write operation from right to left in target area
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(x_out_width<<B2R2BLT_TSZWIN_HEIGHTShift)|config->src_window.height);
+ pt_mem->GROUP1.B2R2_TXY = ((config->dst_window.top)+(config->dst_window.height-1)-(x_out_width*i))<<B2R2_Y_SHIFT|config->dst_window.left;
+
+ }
+
+
+ if(config->rotation == B2R2_ROT_180)
+ {
+ pt_mem->GROUP1.B2R2_TTY |= (B2R2BLT_TTYVSO|B2R2BLT_TTYHSO);
+ pt_mem->GROUP1.B2R2_TXY = (((config->dst_window.top+config->dst_window.height-1)<<B2R2_Y_SHIFT)|(config->dst_window.left+config->dst_window.width-1));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|config->dst_window.width|(config->dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|config->src_window.width|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+
+ }
+
+ }
+
+}
+
+
+void configure_color_conversion(unsigned char no_of_nodes,unsigned char is_src_width_multiple_of_128,\
+ b2r2_buffer_memory *pNode_mem,b2r2_configuration *config)
+{
+ b2r2_link_list *pt_mem;
+ int i=0;
+ unsigned short dst_pixmap_pitch,src_pixmap_pitch;
+ B2R2_RECT src_rsz_inc_rect,dst_rsz_inc_vect;
+ int x_in_offset=0,x_out_offset=0;
+ int x_in_width=128,x_out_width=0;
+ unsigned char no_of_nodes_multiple_of_128=0;
+ unsigned int chroma_rsf=0,luma_rsf=0;
+
+ no_of_nodes_multiple_of_128=(is_src_width_multiple_of_128)? \
+ no_of_nodes:no_of_nodes-1;
+
+ pt_mem= (b2r2_link_list*)(pNode_mem->logical_address);
+ do_pixmap_pitch(config->dst_image.color_format,config->dst_image.width,&dst_pixmap_pitch);
+ do_pixmap_pitch(config->src_image.color_format,config->src_image.width,&src_pixmap_pitch);
+
+ /*For the nodes whose source width is equal to 128*/
+
+ if(config->src_window.width!=config->dst_window.width)
+ {
+ chroma_rsf=compute_the_horizontal_scale_factor(&config->src_window,&config->dst_window,&x_out_width);
+
+ if(x_out_width == 0)
+ {
+ printf("xoutwidth = %d, \n",x_out_width);
+ while(1);
+ }
+ }
+ else
+ {
+ chroma_rsf=0x0400;
+ x_out_width =128;
+ }
+
+ if(config->src_window.height!=config->dst_window.height)
+ {
+ luma_rsf=compute_the_vertical_scale_factor(&config->src_window,&config->dst_window);
+ }
+ else
+ {
+ luma_rsf=0x0400;
+ }
+ for(i=0;i<no_of_nodes_multiple_of_128;i++)
+ {
+ //printf("configure_color_conversion:Node Address:%x\n",pNode_mem->physical_address);
+ pt_mem->GROUP0.B2R2_NIP = pNode_mem->physical_address+(i+1)*sizeof(b2r2_link_list);
+ pt_mem->GROUP0.B2R2_CIC = 0xFFFF;
+ if (config->src_image.color_format == B2R2_YCBCR42XMBN)
+ pt_mem->GROUP0.B2R2_INS = (B2R2BLT_INSIVMX|B2R2BLT_INS2DRESCALE|B2R2_SRC2_FETCH_MEM|B2R2_SRC3_FETCH_MEM);
+ else if (config->src_image.color_format == B2R2_YUV)
+ pt_mem->GROUP0.B2R2_INS = (B2R2BLT_INSIVMX|B2R2BLT_INS2DRESCALE|B2R2_SRC2_FETCH_MEM|B2R2_SRC3_FETCH_MEM|B2R2_SRC1_FETCH_MEM);
+ pt_mem->GROUP0.B2R2_ACK = B2R2_BYPASS_SRC2_SRC3;
+
+ pt_mem->GROUP1.B2R2_TBA = config->dst_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|dst_pixmap_pitch);
+ pt_mem->GROUP1.B2R2_TXY = (config->dst_window.top<<B2R2_Y_SHIFT|(config->dst_window.left+x_out_offset));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|x_out_width|(config->dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ pt_mem->GROUP2.B2R2_S1CF = 0;
+ pt_mem->GROUP2.B2R2_S2CF = 0;
+ if (config->src_image.color_format == B2R2_YCBCR42XMBN)
+ {
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = 0;
+ pt_mem->GROUP3.B2R2_STY = 0;
+ pt_mem->GROUP3.B2R2_SXY = 0;
+ pt_mem->GROUP3.B2R2_SSZ = 0;
+ }
+ else if (config->src_image.color_format == B2R2_YUV)
+ {
+ pt_mem->GROUP3.B2R2_SBA = config->ppp_conf.source_chroma2_address;
+ pt_mem->GROUP3.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|(src_pixmap_pitch/2));
+ pt_mem->GROUP3.B2R2_SXY = ((config->src_window.top/2)<<B2R2_Y_SHIFT|((config->src_window.left+x_in_offset)/2));
+ pt_mem->GROUP3.B2R2_SSZ = (RESVD|(x_in_width/2)|(((config->src_window.height)/2)<<B2R2BLT_TSZWIN_HEIGHTShift));
+ }
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = config->ppp_conf.source_chroma_address;
+ if (config->src_image.color_format == B2R2_YCBCR42XMBN)
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ else if (config->src_image.color_format == B2R2_YUV)
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|(src_pixmap_pitch/2));
+ pt_mem->GROUP4.B2R2_SXY = ((config->src_window.top/2)<<B2R2_Y_SHIFT|((config->src_window.left+x_in_offset)/2));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|(x_in_width/2)|(((config->src_window.height)/2)<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = config->ppp_conf.source_luma_address;
+ pt_mem->GROUP5.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ pt_mem->GROUP5.B2R2_SXY = (config->src_window.top<<B2R2_Y_SHIFT|(config->src_window.left+x_in_offset));
+ pt_mem->GROUP5.B2R2_SSZ = (RESVD|x_in_width|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ /*Clip*/
+ pt_mem->GROUP6.B2R2_CWO = 0;
+ pt_mem->GROUP6.B2R2_CWS = 0;
+
+ /*Clut*/
+ pt_mem->GROUP7.B2R2_CCO = 0;
+ pt_mem->GROUP7.B2R2_CML = 0;
+
+ pt_mem->GROUP8.B2R2_FCTL=0x22000044;
+ pt_mem->GROUP8.B2R2_PMK =0;
+
+ pt_mem->GROUP9.B2R2_RSF=(((luma_rsf/2)<<16)|(chroma_rsf/2));
+ pt_mem->GROUP9.B2R2_RZI=0x30003000;
+ pt_mem->GROUP9.B2R2_HFP=0;
+ pt_mem->GROUP9.B2R2_VFP=0;
+
+ pt_mem->GROUP10.B2R2_RSF=((luma_rsf<<16)|chroma_rsf);
+ pt_mem->GROUP10.B2R2_RZI=0x30003000;
+ pt_mem->GROUP10.B2R2_HFP=0;
+ pt_mem->GROUP10.B2R2_VFP=0;
+
+ pt_mem->GROUP12.B2R2_KEY1=0;
+ pt_mem->GROUP12.B2R2_KEY2=0;
+
+ pt_mem->GROUP15.B2R2_VMX0 = 0x2C440000;//0x3324a800;
+ pt_mem->GROUP15.B2R2_VMX1 = 0xE9A403AA;//0xe604ab9c;
+ pt_mem->GROUP15.B2R2_VMX2 = 0x0004013F;//0x0004a957;
+ pt_mem->GROUP15.B2R2_VMX3 = 0x34F21322;//0x32121eeb;
+
+ x_in_offset+=128;
+ x_out_offset+=x_out_width;
+ if((i==no_of_nodes_multiple_of_128-1)&&(is_src_width_multiple_of_128))
+ {
+ pt_mem->GROUP0.B2R2_NIP= 0;
+ //pt_mem->GROUP0.B2R2_INS |=B2R2BLT_INSBlitCompIRQ ;
+ }
+ else
+ {
+ pt_mem++;
+ }
+ }
+
+ /*For the node whose source width less than 128*/
+ if(is_src_width_multiple_of_128==0)
+ {
+ pt_mem->GROUP0.B2R2_NIP= 0;
+
+ pt_mem->GROUP0.B2R2_CIC = 0xFFFF;
+ if (config->src_image.color_format == B2R2_YCBCR42XMBN)
+ pt_mem->GROUP0.B2R2_INS = (B2R2BLT_INSIVMX|B2R2BLT_INS2DRESCALE|B2R2_SRC2_FETCH_MEM|B2R2_SRC3_FETCH_MEM);
+ else if (config->src_image.color_format == B2R2_YUV)
+ pt_mem->GROUP0.B2R2_INS = (B2R2BLT_INSIVMX|B2R2BLT_INS2DRESCALE|B2R2_SRC2_FETCH_MEM|B2R2_SRC3_FETCH_MEM|B2R2_SRC1_FETCH_MEM);
+ pt_mem->GROUP0.B2R2_ACK = B2R2_BYPASS_SRC2_SRC3;
+
+ pt_mem->GROUP1.B2R2_TBA = config->dst_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|dst_pixmap_pitch);
+ pt_mem->GROUP1.B2R2_TXY = (config->dst_window.top<<B2R2_Y_SHIFT|(config->dst_window.left+x_out_offset));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(config->dst_window.width-x_out_offset)|(config->dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ pt_mem->GROUP2.B2R2_S1CF = 0;
+ pt_mem->GROUP2.B2R2_S2CF = 0;
+
+ if (config->src_image.color_format == B2R2_YCBCR42XMBN)
+ {
+ /*Source1*/
+ pt_mem->GROUP3.B2R2_SBA = 0;
+ pt_mem->GROUP3.B2R2_STY = 0;
+ pt_mem->GROUP3.B2R2_SXY = 0;
+ pt_mem->GROUP3.B2R2_SSZ = 0;
+ }
+ else if (config->src_image.color_format == B2R2_YUV)
+ {
+ pt_mem->GROUP3.B2R2_SBA = config->ppp_conf.source_chroma2_address;
+ pt_mem->GROUP3.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|(src_pixmap_pitch/2));
+ pt_mem->GROUP3.B2R2_SXY = ((config->src_window.top/2)<<B2R2_Y_SHIFT|((config->src_window.left+x_in_offset)/2));
+ pt_mem->GROUP3.B2R2_SSZ = (RESVD|((config->src_window.width-x_in_offset)/2)|((config->src_window.height/2)<<B2R2BLT_TSZWIN_HEIGHTShift));
+ }
+
+ /*Source2*/
+ pt_mem->GROUP4.B2R2_SBA = config->ppp_conf.source_chroma_address;
+ if(config->src_image.color_format == B2R2_YCBCR42XMBN)
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ else if (config->src_image.color_format == B2R2_YUV)
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|(src_pixmap_pitch/2));
+ pt_mem->GROUP4.B2R2_SXY = ((config->src_window.top/2)<<B2R2_Y_SHIFT|((config->src_window.left+x_in_offset)/2));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|((config->src_window.width-x_in_offset)/2)|((config->src_window.height/2)<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ /*Source3*/
+ pt_mem->GROUP5.B2R2_SBA = config->ppp_conf.source_luma_address;
+ pt_mem->GROUP5.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|src_pixmap_pitch);
+ pt_mem->GROUP5.B2R2_SXY = (config->src_window.top<<B2R2_Y_SHIFT|(config->src_window.left+x_in_offset));
+ pt_mem->GROUP5.B2R2_SSZ = (RESVD|(config->src_window.width-x_in_offset)|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+
+ /*Clip*/
+ pt_mem->GROUP6.B2R2_CWO = 0;
+ pt_mem->GROUP6.B2R2_CWS = 0;
+
+ /*Clut*/
+ pt_mem->GROUP7.B2R2_CCO = 0;
+ pt_mem->GROUP7.B2R2_CML = 0;
+
+ pt_mem->GROUP8.B2R2_FCTL=0x22000044;
+ pt_mem->GROUP8.B2R2_PMK =0;
+
+ pt_mem->GROUP9.B2R2_RSF=(((luma_rsf/2)<<16)|(chroma_rsf/2));
+ pt_mem->GROUP9.B2R2_RZI=0x30003000;
+ pt_mem->GROUP9.B2R2_HFP=0;
+ pt_mem->GROUP9.B2R2_VFP=0;
+
+ pt_mem->GROUP10.B2R2_RSF=((luma_rsf<<16)|chroma_rsf);
+ pt_mem->GROUP10.B2R2_RZI=0x30003000;
+ pt_mem->GROUP10.B2R2_HFP=0;
+ pt_mem->GROUP10.B2R2_VFP=0;
+
+ pt_mem->GROUP12.B2R2_KEY1=0;
+ pt_mem->GROUP12.B2R2_KEY2=0;
+
+ pt_mem->GROUP15.B2R2_VMX0 = 0x2C440000;//0x3324a800;
+ pt_mem->GROUP15.B2R2_VMX1 = 0xE9A403AA;//0xe604ab9c;
+ pt_mem->GROUP15.B2R2_VMX2 = 0x0004013F;//0x0004a957;
+ pt_mem->GROUP15.B2R2_VMX3 = 0x34F21322;//0x32121eeb;
+
+ }
+
+}
+
+static unsigned int compute_the_horizontal_scale_factor(B2R2_RECT *psrc_window,
+ B2R2_RECT *pdst_window,int *x_out_width)
+{
+ unsigned scale_fr=0;/*scale factor in 6.10 format*/
+
+ scale_fr =((psrc_window->width*1024)/pdst_window->width);
+ scale_fr&=0xFFFF;
+ *x_out_width=(128*1024)/scale_fr;
+#if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+ printf("Horizontal scale_fr = %d, \n",scale_fr);
+ printf("xoutwidth down= %d, \n",*x_out_width);
+#endif
+
+ return scale_fr;
+}
+
+static unsigned int compute_the_vertical_scale_factor(B2R2_RECT *psrc_window,\
+ B2R2_RECT *pdst_window)
+{
+ unsigned scale_fr=0;/*scale factor in 6.10 format*/
+
+ scale_fr =((psrc_window->height*1024)/pdst_window->height);
+ scale_fr&=0xFFFF;
+
+ return scale_fr;
+}
+
+
+static void configure_node_for_b2r2_op(b2r2_library *library,b2r2_configuration *config)
+{
+
+ b2r2_link_list *pt_mem;
+ unsigned short pixmap_pitch;
+
+ pt_mem=(b2r2_link_list*)(config->NodeAdress);
+
+ memset((unsigned char*)pt_mem,0,sizeof(b2r2_link_list));
+
+ pt_mem->GROUP0.B2R2_NIP = NEXT_NODE_NULL;
+ pt_mem->GROUP0.B2R2_CIC = 0x1FFF;
+ pt_mem->GROUP0.B2R2_INS = B2R2BLT_INSBlitCompIRQ;
+
+ /*Configure sources and destinations*/
+ if(config->dst_image.physical_address == 0)
+ {
+ pt_mem->GROUP0.B2R2_ACK =B2R2_BYPASS_SRC1;
+ pt_mem->GROUP0.B2R2_INS |=B2R2_SRC1_FETCH_MEM;
+
+ do_pixmap_pitch(config->src_image.color_format,config->src_image.width,&pixmap_pitch);
+
+ pt_mem->GROUP1.B2R2_TBA = config->src_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|pixmap_pitch);
+ pt_mem->GROUP1.B2R2_TXY = (config->src_window.top<<B2R2_Y_SHIFT|config->src_window.left);
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(config->src_window.width)|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ pt_mem->GROUP3.B2R2_SBA = config->src_image.physical_address;
+ pt_mem->GROUP3.B2R2_STY = pt_mem->GROUP1.B2R2_TTY;
+ pt_mem->GROUP3.B2R2_SXY = pt_mem->GROUP1.B2R2_TXY;
+ pt_mem->GROUP3.B2R2_SSZ = pt_mem->GROUP1.B2R2_TSZ;
+
+ if(config->is_color_fill_en)
+ {
+ pt_mem->GROUP0.B2R2_INS=B2R2_SRC1_DIRECT_FILL;
+ pt_mem->GROUP2.B2R2_S2CF = 0;
+ pt_mem->GROUP2.B2R2_S1CF = config->color_fill.color;
+ }
+ }
+ else
+ {
+ do_pixmap_pitch(config->dst_image.color_format,config->dst_image.width,&pixmap_pitch);
+ //printf("pixmap pitch is %x \n",pixmap_pitch);
+
+ pt_mem->GROUP1.B2R2_TBA = config->dst_image.physical_address;
+ pt_mem->GROUP1.B2R2_TTY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->dst_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|pixmap_pitch);
+ pt_mem->GROUP1.B2R2_TXY = (config->dst_window.top<<B2R2_Y_SHIFT|(config->dst_window.left));
+ pt_mem->GROUP1.B2R2_TSZ = (RESVD|(config->dst_window.width)|(config->dst_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ if(config->is_alpha_blend_en)
+ {
+ pt_mem->GROUP0.B2R2_ACK |=((config->alpha_blend.val<<B2R2BLT_ACKGALPHA_ROPIDShift)|(config->alpha_blend.swap_fg_bg)|(config->alpha_blend.premuliplier));;
+ pt_mem->GROUP0.B2R2_INS |=(B2R2_SRC2_FETCH_MEM|B2R2_SRC1_FETCH_MEM);
+
+ pt_mem->GROUP1.B2R2_TTY |=config->alpha_blend.range<<B2R2_ALPHA_RANGE_SHIFT;
+
+ pt_mem->GROUP3.B2R2_SBA = pt_mem->GROUP1.B2R2_TBA;
+ pt_mem->GROUP3.B2R2_STY = pt_mem->GROUP1.B2R2_TTY;
+ pt_mem->GROUP3.B2R2_SXY = pt_mem->GROUP1.B2R2_TXY;
+ pt_mem->GROUP3.B2R2_SSZ = pt_mem->GROUP1.B2R2_TSZ;
+ }
+ else if(config->is_rop_ops_en)
+ {
+ pt_mem->GROUP0.B2R2_INS |=(B2R2_SRC2_FETCH_MEM|B2R2_SRC1_FETCH_MEM);
+ pt_mem->GROUP0.B2R2_ACK |=((config->rop.logi_op<<B2R2BLT_ACKGALPHA_ROPIDShift)|B2R2_LOGICAL_OPER);
+
+ pt_mem->GROUP3.B2R2_SBA = pt_mem->GROUP1.B2R2_TBA;
+ pt_mem->GROUP3.B2R2_STY = pt_mem->GROUP1.B2R2_TTY;
+ pt_mem->GROUP3.B2R2_SXY = pt_mem->GROUP1.B2R2_TXY;
+ pt_mem->GROUP3.B2R2_SSZ = pt_mem->GROUP1.B2R2_TSZ;
+ }
+ else
+ {
+ pt_mem->GROUP0.B2R2_ACK |=B2R2_BYPASS_SRC2_SRC3;
+ pt_mem->GROUP0.B2R2_INS |=B2R2_SRC2_FETCH_MEM;
+
+ if(config->is_color_fill_en)
+ {
+ pt_mem->GROUP0.B2R2_INS |=B2R2_SRC2_COLOR_FILL;
+ pt_mem->GROUP2.B2R2_S1CF = 0;
+ pt_mem->GROUP2.B2R2_S2CF = config->color_fill.color;
+ }
+ }
+
+ do_pixmap_pitch(config->src_image.color_format,config->src_image.width,&pixmap_pitch);
+
+ pt_mem->GROUP4.B2R2_SBA = config->src_image.physical_address;
+ pt_mem->GROUP4.B2R2_STY = (RESVD|(0<<B2R2_ALPHA_RANGE_SHIFT)|(config->src_image.color_format<<B2R2BLT_TTYCOLOR_FORMShift)|pixmap_pitch);
+ pt_mem->GROUP4.B2R2_SXY = (config->src_window.top<<B2R2_Y_SHIFT|(config->src_window.left));
+ pt_mem->GROUP4.B2R2_SSZ = (RESVD|(config->src_window.width)|(config->src_window.height<<B2R2BLT_TSZWIN_HEIGHTShift));
+
+ }
+
+ if(config->is_rect_clip_en)
+ {
+ pt_mem->GROUP0.B2R2_INS |=B2R2BLT_INSRECT_CLIP;
+
+
+ pt_mem->GROUP6.B2R2_CWO =((config->rect_clip.rect.top<<B2R2BLT_CWOYDOShift)| \
+ config->rect_clip.rect.left);
+ pt_mem->GROUP6.B2R2_CWS =(((config->rect_clip.rect.top+config->rect_clip.rect.height)<<B2R2BLT_CWSYDSShift)| \
+ (config->rect_clip.rect.left+config->rect_clip.rect.width));
+
+ if(config->rect_clip.clip_mode==B2R2_INSIDE_CLIP)
+ {
+ pt_mem->GROUP6.B2R2_CWO &=0x7FFFFFFF;
+ }
+ else
+ {
+ pt_mem->GROUP6.B2R2_CWO |=(0x80000000);
+ }
+ }
+
+ if(config->is_color_key_en)
+ {
+ pt_mem->GROUP0.B2R2_INS |= B2R2BLT_INSCKEY;
+ pt_mem->GROUP0.B2R2_ACK |= (RESVD|(config->color_key.sel<<B2R2BLT_ACKCKEY_SELShift)| \
+ ((config->color_key.config.color.val & 0x3F)<<B2R2BLT_ACKACK_CKEYShift)); //Fetch from source2
+
+ pt_mem->GROUP12.B2R2_KEY1 =
+ ((((config->color_key.color&0xFF000000)>>24)<<B2R2BLT_KEY1ALPHA0Shift)| \
+ ((((config->color_key.color&0xF800)>>11)<<3)<<B2R2BLT_KEY1RED_MINShift)| \
+ ((((config->color_key.color&0x07E0)>>5)<<2)<<B2R2BLT_KEY1GREEN_MINShift)| \
+ ((config->color_key.color&0x1F)<<3));
+
+ pt_mem->GROUP12.B2R2_KEY2 =
+ ((((config->color_key.color&0xFF000000)>>24)<<B2R2BLT_KEY1ALPHA0Shift)| \
+ (((((config->color_key.color&0xF800)>>11)<<3)|0x7)<<B2R2BLT_KEY1RED_MINShift)| \
+ (((((config->color_key.color&0x07E0)>>5)<<2)|0x3)<<B2R2BLT_KEY1GREEN_MINShift)| \
+ (((config->color_key.color&0x1F)<<3)|0x7));
+ }
+ return;
+
+}
+
+void debug_print_node_data(unsigned int node_addr,unsigned int sizeinwords)
+{
+ volatile unsigned int *pdata,i,temp;
+ pdata =(unsigned int*)node_addr ;
+
+ for(i=0;i<sizeinwords;i++)
+ {
+ printf("Address =0x%x ,data=0x%x \n",pdata,*pdata);
+ pdata++;
+ }
+}
+
+
+
+int b2r2_library_operation_deconfigure(b2r2_library *library,b2r2_configuration *config)
+{
+
+ b2r2_driver_memory driver_memory;
+ int size=config->no_of_nodes*sizeof(b2r2_link_list);
+
+#if DEBUG_PRINTF
+ printf("%s\n",__FUNCTION__);
+#endif
+
+ /** Assign the size of memory */
+ driver_memory.size_of_memory=size;
+ driver_memory.physical_address=config->NodePhysicalAdress;
+
+ /** Get the physical address of that memory */
+ ioctl(library->file_pointer,B2R2_DEALLOCATE_MEMORY,&driver_memory);
+
+ munmap(config->NodeAdress,size);
+
+ return 0;
+}
+
+
+
+
+
+
+
+
+
+
diff --git a/b2r2_api.h b/b2r2_api.h
new file mode 100644
index 0000000..fe3ae87
--- /dev/null
+++ b/b2r2_api.h
@@ -0,0 +1,1045 @@
+/*---------------------------------------------------------------------------*/
+/* © copyright STMicroelectronics(Wireless),2008. All rights reserved. For */
+/* information, STMicroelectronics(Wireless)reserves the right to license */
+/* this software concurrently under separate license conditions. */
+/* */
+/* This program is free software; you can redistribute it and/or modify it */
+/* under the terms of the GNU Lesser General Public License as published */
+/* by the Free Software Foundation; either version 2.1 of the License, */
+/* or (at your option)any later version. */
+/* */
+/* This program is distributed in the hope that it will be useful, but */
+/* WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See */
+/* the GNU Lesser General Public License for more details. */
+/* */
+/* You should have received a copy of the GNU Lesser General Public License */
+/* along with this program. If not, see <http://www.gnu.org/licenses/>. */
+/*---------------------------------------------------------------------------*/
+
+
+
+#ifndef __B2R2_API_H
+#define __B2R2_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* _cplusplus */
+
+
+/***************************** b2r2 library basic opertaions *************************/
+
+
+/**
+
+ b2r2 library instance handler
+
+ Type : Structure
+
+ Usage: Any task which uses B2R2 should this handler.
+ Multiple B2R2 operations can be invoked from
+ same library handler.
+
+ Member: file_pointer: This is a handler to B2R2 driver.
+
+*/
+
+typedef struct b2r2_library
+{
+ int file_pointer;
+
+
+}b2r2_library;
+
+
+/**
+
+ b2r2 library memory handler
+
+ Type : Structure
+
+ Usage: Any task which wants to allocate memory should use
+ this structure.size of memory field should be populated.
+ and in turn from b2r2_library_allocate function
+ physical_address and logical address will be populated.
+
+ Member: physical_address: physical address in unsigned int format
+ logical_address : logical address in unsigned int format
+ size_of_memory : size of the memory in bytes.
+
+*/
+
+typedef struct b2r2_buffer_memory
+{
+
+ unsigned int physical_address;
+ unsigned int logical_address;
+ unsigned int size_of_memory;
+
+}b2r2_buffer_memory;
+
+
+/** b2r2 library instance API */
+
+/**
+
+ b2r2 library init
+
+ Type : Public API
+
+ Usage: Task should invoke this function before call
+ to any other function.This will initilize
+ one library instance.
+
+ Parameters: In/Out : b2r2_library :b2r2 library instance handler
+
+*/
+
+void b2r2_library_init(b2r2_library*);
+
+/**
+
+ b2r2 library close
+
+ Type : Public API
+
+ Usage: Task should invoke this function after completed
+ all B2R2 operations to terminate.
+
+ Parameters: In/Out : b2r2_library :b2r2 library instance handler
+
+*/
+
+
+void b2r2_library_close(b2r2_library*);
+
+
+/** b2r2 library memory API */
+
+
+/**
+
+ b2r2 library allocate
+
+ Type : Public API
+
+ Usage: Task should invoke this function for
+ allocating the memory from kernel space
+ This memory in general can be used for input/output
+ buffers
+
+ Parameters: In : b2r2_library :b2r2 library instance handler
+ In/Out : b2r2_buffer_memory :b2r2 library memory handler
+
+*/
+
+void b2r2_library_allocate(b2r2_library*,b2r2_buffer_memory*);
+
+
+/**
+
+ b2r2 library deallocate
+
+ Type : Public API
+
+ Usage: Task should invoke this function for
+ deallocating the memory from kernel space
+
+ Parameters: In : b2r2_library :b2r2 library instance handler
+ In/Out : b2r2_buffer_memory :b2r2 library memory handler
+*/
+
+
+void b2r2_library_deallocate(b2r2_library*,b2r2_buffer_memory*);
+
+/**************************************************************************************/
+
+
+/************************ b2r2 operations *********************************************/
+
+/**
+
+ b2r2 gfx color format
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the color format used.
+
+*/
+
+
+
+
+typedef enum
+{
+ B2R2_RGB565 = 0,
+ B2R2_RGB888 = 1,
+ B2R2_ARGB8565 = 4,
+ B2R2_ARGB8888 = 5,
+ B2R2_ARGB1555 = 6,
+ B2R2_ARGB4444 = 7,
+ B2R2_YCBCR888 = 16,
+ B2R2_YCBCR422R = 18,
+ B2R2_AYCBCR8888 = 21,
+ B2R2_YCBCR42XMB = 20,
+ B2R2_YCBCR42XR2B = 22,
+ B2R2_YCBCR42XMBN = 14,
+ B2R2_CLUT1 = 8,
+ B2R2_CLUT2 = 9,
+ B2R2_CLUT4 = 10,
+ B2R2_CLUT8 = 11,
+ B2R2_ACLUT44 = 12,
+ B2R2_ACLUT88 = 13,
+ B2R2_A1 = 24,
+ B2R2_A8 = 25,
+ B2R2_YUV = 30
+
+}b2r2_gfx_color_form;
+
+
+/**
+
+ b2r2 postprocessor rot type
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the type of rotation
+
+*/
+
+
+
+typedef enum
+{
+ B2R2_ROT_0 =0,
+ B2R2_ROT_90 = 1,
+ B2R2_ROT_180 = 2,
+ B2R2_ROT_270 = 3,
+ B2R2_CLOCKWISE_ROT_270=B2R2_ROT_90,
+ B2R2_CLOCKWISE_ROT_90=B2R2_ROT_270,
+ B2R2_CLOCKWISE_ROT_180=B2R2_ROT_180
+
+}b2r2_postprocessor_rot_type;
+
+
+/**
+
+ b2r2 colour fill
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the color fill
+
+*/
+
+
+typedef enum
+{
+ B2R2_COLOUR_FILL_DISABLE = 0,
+ B2R2_COLOUR_FILL_ENABLE = 1
+
+}B2R2_COLOUR_FILL;
+
+
+/**
+
+ b2r2 colour key
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the color key
+
+*/
+
+typedef enum
+{
+ B2R2_COLOUR_KEY_DISABLE = 0,
+ B2R2_COLOUR_KEY_ENABLE = 1
+
+}B2R2_COLOUR_KEY;
+
+
+/**
+
+ b2r2 alpha blending
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the alpha blending
+
+*/
+
+typedef enum
+{
+ B2R2_ALPHA_BLENDING_DISABLE = 0,
+ B2R2_ALPHA_BLENDING_ENABLE = 1
+
+}B2R2_ALPHA_BLENDING;
+
+
+/**
+
+ b2r2 rectangular clip
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the rectangular clipping
+
+*/
+
+typedef enum
+{
+ B2R2_RECTANGULAR_CLIP_DISABLE = 0,
+ B2R2_RECTANGULAR_CLIP_ENABLE = 1
+
+}B2R2_RECTANGULAR_CLIP;
+
+
+/**
+
+ b2r2 rop
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the boolean operations
+
+*/
+
+
+typedef enum
+{
+ B2R2_ROP_DISABLE = 0,
+ B2R2_ROP_ENABLE = 1
+
+}B2R2_ROP;
+
+
+/**
+
+ b2r2 color key sel
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify the color key selection
+
+*/
+
+
+typedef enum
+{
+ B2R2_DEST_COLOR_KEY = 0,
+ B2R2_SRC_COLOR_KEY_BEFORE_CLUT = 1,
+ B2R2_SRC_COLOR_KEY_AFTER_CLUT = 2,
+ B2R2_BLANKING_SRC_ALPHA = 3
+}B2R2_COLOR_KEY_SEL;
+
+
+/**
+
+ b2r2 blend swap fg bg
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify foreground or background
+
+*/
+
+
+
+typedef enum
+{
+ B2R2_BLEND_SWAP_FG_BG_DISABLE=0,
+ B2R2_BLEND_SWAP_FG_BG_ENABLE=1
+
+}B2R2_BLEND_SWAP_FG_BG;
+
+
+/**
+
+ b2r2 blend fg premultiplier
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify foreground premultiplier
+
+*/
+
+
+
+typedef enum
+{
+ B2R2_BLENDING_FG_NOT_PREMULT = 2,
+ B2R2_BLENDING_FG_PREMULT = 3
+
+}B2R2_BLEND_FG_PREMULTIPLIER;
+
+
+
+/**
+
+ b2r2 blend alpha range
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify blending alpha range
+
+*/
+
+
+typedef enum
+{
+ B2R2_ALPHA_RANGE_0_128 = 0,
+ B2R2_ALPHA_RANGE_0_255 = 1
+
+}B2R2_BLEND_ALPHA_RANGE;
+
+
+/**
+
+ b2r2 logical op
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify logical operations
+
+*/
+
+
+typedef enum
+{
+ B2R2_ALU_CLEAR = 0,
+ B2R2_ALU_AND = 1,
+ B2R2_ALU_AND_REV = 2,
+ B2R2_ALU_COPY = 3,
+ B2R2_ALU_AND_INVERT = 4,
+ B2R2_ALU_NOOP = 5,
+ B2R2_ALU_XOR = 6,
+ B2R2_ALU_OR = 7,
+ B2R2_ALU_NOR = 8,
+ B2R2_ALU_EQUIV = 9,
+ B2R2_ALU_INVERT = 10,
+ B2R2_ALU_OR_REVERSE = 11,
+ B2R2_ALU_COPY_INVERT = 12,
+ B2R2_ALU_OR_INVERT = 13,
+ B2R2_ALU_NAND = 14,
+ B2R2_ALU_SET = 15,
+ B2R2_ALU_ALPHA_BLEND = 16
+
+} b2r2_logical_op;
+
+
+/**
+
+ b2r2 update params
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify update parameters
+
+*/
+
+typedef enum
+{
+ B2R2_FILL_COLOR_OP_PARAMS =0,
+ B2R2_ALPHA_BLEND_OP_PARAMS =1,
+ B2R2_COLOR_KEY_OP_PARMS =2,
+ B2R2_ROTATION_OP_PARAMS =3,
+ B2R2_CLIP_OP_PARAMS =4,
+ B2R2_RESIZE_OP_PARAMS =5,
+ B2R2_ROP_OP_PARAMS =6,
+ B2R2_COLOR_CONVERSION_OF_PARAMS = 7,
+ B2R2_DESTINATION_ADDRESS_OF_PARAMS = 8,
+ B2R2_SOURCE_ADDRESS_OF_PARAMS = 9
+
+}B2R2_UPDATE_PARAMS;
+
+
+/**
+
+ b2r2 clip mode
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify clip mode
+
+*/
+
+
+typedef enum
+{
+ B2R2_INSIDE_CLIP = 0,
+ B2R2_OUTSIDE_CLIP = 1
+
+}B2R2_CLIP_MODE;
+
+
+/**
+
+ b2r2 job prority
+
+ Type : Enumeration
+
+ Usage: This enum is used to identify priority of b2r2 job
+
+*/
+
+
+
+typedef enum
+{
+
+B2R2_PRIORITY_1=0x1,
+B2R2_PRIORITY_2=0x2,
+B2R2_PRIORITY_3=0x4,
+B2R2_PRIORITY_4=0x8,
+B2R2_PRIORITY_5=0xc,
+B2R2_PRIORITY_6=0x10,
+B2R2_PRIORITY_7=0x20
+
+}b2r2_job_priority;
+
+
+
+/**
+
+ b2r2 rect
+
+ Type : Structure
+
+ Usage: This structure is used to define a
+ rectangular position.This will
+ start from top & left location of a frame.
+
+ Member: left: left location
+ top : top location
+ width: width of rectangle
+ height: height of rectangle
+*/
+
+
+
+typedef struct
+{
+ unsigned int left;
+ unsigned int top;
+ unsigned int width;
+ unsigned int height;
+
+}B2R2_RECT,*PB2R2_RECT;
+
+
+
+/**
+
+ b2r2 point
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ a pixel location in a frame
+
+ Member: xpos : x-axis position
+ ypos : y-axis position
+*/
+
+
+typedef struct
+{
+ unsigned int xpos;
+ unsigned int ypos;
+
+}B2R2_POINT,*PB2R2_POINT;
+
+
+
+/**
+
+ b2r2 job params
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ job parameters of B2R2
+
+ Member: job_logical_address: job logical address
+ job_physical_address: job physical address
+ job_pace_lna_physical_address: job last node physical address
+ job_size: job size
+ jobid: job ID
+*/
+
+
+
+typedef struct
+{
+ unsigned int job_logical_address;
+ unsigned int job_physical_address;
+ unsigned int job_pace_lna_physical_address;
+ unsigned int job_size;
+ unsigned int jobid;
+ b2r2_job_priority priority;
+}B2R2_JOB_PARAMS;
+
+
+
+/**
+
+ b2r2 colour fill params
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ color fill parameters
+
+ Member: enable : enable
+ color : color
+*/
+
+
+
+typedef struct
+{
+ unsigned char enable;
+ unsigned int color;
+
+}B2R2_COLOUR_FILL_PARAMS;
+
+
+/**
+
+ b2r2 color key config
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ color configfuration
+
+ Member: color :red,green and blue color configurations.
+*/
+
+
+
+typedef struct
+{
+ union
+ {
+ unsigned char red:2;
+ unsigned char green:2;
+ unsigned char blue:2;
+ unsigned char resv:2;
+
+ unsigned char val;
+ }color;
+
+}B2R2_COLOR_KEY_CONFIG;
+
+
+
+/**
+
+ b2r2 colour key params
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ color key parameters
+
+ Member: enable :color key enable
+ val :color key value
+ config :color key configuration
+ color :color
+*/
+
+
+
+typedef struct
+{
+ unsigned char enable;
+ B2R2_COLOR_KEY_SEL sel;
+ B2R2_COLOR_KEY_CONFIG config;
+ unsigned int color;
+
+}B2R2_COLOUR_KEY_PARAMS;
+
+
+/**
+
+ b2r2 blend params
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ blending parameters
+
+ Member: enable :blending enable
+ val :blending value
+ range : blending range
+ swap_fg_bg :foreground or background
+ premuliplier : premultiplier
+*/
+
+
+typedef struct
+{
+ unsigned char enable;
+ unsigned char val;
+ B2R2_BLEND_ALPHA_RANGE range;
+ B2R2_BLEND_SWAP_FG_BG swap_fg_bg;
+ B2R2_BLEND_FG_PREMULTIPLIER premuliplier;
+
+}B2R2_BLEND_PARAMS;
+
+
+
+/**
+
+ b2r2 rectangular clip params
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ rectangular clipping parameters
+
+ Member: enable :rectangular clipping enable
+ clip_mode : cliping mode
+ rect : cliping rectangle
+
+*/
+
+
+
+
+typedef struct
+{
+ unsigned char enable;
+ B2R2_CLIP_MODE clip_mode;
+ B2R2_RECT rect;
+
+}B2R2_RECTANGULAR_CLIP_PARAMS;
+
+
+
+
+/**
+
+ b2r2 rop params
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ rop parameters
+
+ Member: enable :rop enable
+ logi_op : logical operatiion
+
+*/
+
+
+
+typedef struct
+{
+ unsigned char enable;
+ b2r2_logical_op logi_op;
+
+}B2R2_ROP_PARAMS;
+
+
+
+/**
+
+ b2r2 image data
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ image data
+
+ Member: color_format : color format
+ physical_address : physical address
+ width : width of the image
+ height : height of the image
+
+
+*/
+
+
+
+typedef struct
+{
+ b2r2_gfx_color_form color_format;
+ unsigned int physical_address;
+ unsigned int width;
+ unsigned int height;
+}B2R2_IMAGE_DATA,*PB2R2_IMAGE_DATA;
+
+
+
+/**
+
+ b2r2 postprocessor conf
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ postprocessor configuration
+
+ Member: source_chroma_address : chroma address
+ source_chroma2_address : chroma 2 address
+ source_luma_address : luma address
+
+*/
+
+
+
+typedef struct {
+
+ unsigned int source_chroma_address;
+ unsigned int source_chroma2_address;
+ unsigned int source_luma_address;
+
+} b2r2_postprocessor_conf;
+
+
+/**
+
+ b2r2 window params
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ window parameters
+
+ Member: src_window : source window
+ dst_window : destination window
+ clip_window : clip window
+
+*/
+
+
+typedef struct
+{
+ B2R2_RECT src_window;
+ B2R2_RECT dst_window;
+ B2R2_RECT clip_window;
+
+}B2R2_WINDOW_PARAMS;
+
+
+
+/**
+
+ b2r2 update params val
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ update parameters
+
+ Member: val : val parameter
+ window_params : window parameters
+ ppp_params : post processor parameters
+
+*/
+
+
+
+typedef struct
+{
+ unsigned int val;
+
+ B2R2_WINDOW_PARAMS window_params;
+ b2r2_postprocessor_conf ppp_params;
+
+}B2R2_UPDATE_PARAMS_VAL;
+
+
+
+/**
+
+ b2r2 configuration
+
+ Type : Structure
+
+ Usage: This structure is used to define
+ b2r2 configuraion.Multiple configuartions can be
+ used for implementing multiple B2R2 operations
+
+ Member: src_image : source image data
+ dst_image : destination image data
+ src_window : source window
+ dst_window : destination window
+
+ rotation: rotation parameters
+ ppp_conf: post-processor parameters
+ color_fill: color fill parameters
+ color_key: color key parameters
+ alpha_blend:alpha blending parameters
+ rect_clip: rectangular clipping parameters
+ rop: rop parameters
+ job: job parameters
+
+ NodeAdress: node addess of configuration
+ NodePhysicalAdress: node physical addess of configuration
+ last_nodeAdress: last-node addess of configuration
+ no_of_nodes: number of nodes of the configuration
+
+ is_resize: is resize operation there in configuration
+ is_rotation: is rotation operation there in configuration
+ is_color_conversion: is color conversion operation there in configuration
+ is_color_key_en: is color_key operation there in configuration
+ is_alpha_blend_en: is alpha_blend operation there in configuration
+ is_rect_clip_en: is rect_clip operation there in configuration
+ is_color_fill_en: is color_fill operation there in configuration
+ is_rop_ops_en: is rop_ops operation there in configuration
+
+*/
+
+
+
+
+typedef struct
+{
+ B2R2_IMAGE_DATA src_image;
+ B2R2_IMAGE_DATA dst_image;
+ B2R2_RECT src_window;
+ B2R2_RECT dst_window;
+
+ /** Rotation mode */
+ b2r2_postprocessor_rot_type rotation;
+ /** post processor configuration */
+ b2r2_postprocessor_conf ppp_conf;
+ /** Color fill*/
+ B2R2_COLOUR_FILL_PARAMS color_fill;
+ /** Color key*/
+ B2R2_COLOUR_KEY_PARAMS color_key;
+ /** Alpha blending*/
+ B2R2_BLEND_PARAMS alpha_blend;
+ /** Rectangular clipping*/
+ B2R2_RECTANGULAR_CLIP_PARAMS rect_clip;
+ /** Rop Operations params*/
+ B2R2_ROP_PARAMS rop;
+
+ B2R2_JOB_PARAMS job;
+
+
+ unsigned int NodeAdress;
+ unsigned int NodePhysicalAdress;
+ unsigned int last_nodeAdress;
+ unsigned char no_of_nodes;
+ unsigned char is_resize;
+ unsigned char is_rotation;
+ unsigned char is_color_conversion;
+ unsigned char is_color_key_en;
+ unsigned char is_alpha_blend_en;
+ unsigned char is_rect_clip_en;
+ unsigned char is_color_fill_en;
+ unsigned char is_rop_ops_en;
+
+
+}b2r2_configuration;
+
+
+
+/**
+
+ b2r2 library operation configure
+
+ Type : Public API
+
+ Usage: Task should invoke this function for one B2R2 configuration
+ Libary will make job linked list for the corresponding operation.
+ Memory for that particular job is allocated in library itself.
+
+ Parameters: In/Out : b2r2_library :b2r2 library instance handler
+ In/Out : b2r2_configuration :b2r2 library configuration
+
+*/
+
+
+
+int b2r2_library_operation_configure(b2r2_library *library,b2r2_configuration *config);
+
+
+/**
+
+ b2r2 library operation deconfigure
+
+ Type : Public API
+
+ Usage: Task should invoke this function after B2R2 configuraion is no
+ more used.It will internal memory deallocation.
+
+ Parameters: In/Out : b2r2_library :b2r2 library instance handler
+ In/Out : b2r2_configuration :b2r2 library configuration
+
+*/
+
+
+
+int b2r2_library_operation_deconfigure(b2r2_library *library,b2r2_configuration *config);
+
+
+
+/**
+
+ b2r2 library update params
+
+ Type : Public API
+
+ Usage: Task should invoke this function if parameter in b2r2 configuartion
+ need to be changed without creating a new configuration.
+
+ Parameters: In/Out : b2r2_library :b2r2 library instance handler
+ In/Out : b2r2_configuration :b2r2 library configuration
+ In : b2r2_update_params : Update parameters
+ In : b2r2_update_params_val: Updated value
+
+*/
+
+void b2r2_library_update_params(b2r2_library *library,b2r2_configuration *config,
+ B2R2_UPDATE_PARAMS params,B2R2_UPDATE_PARAMS_VAL *pVal);
+
+
+/**
+
+ b2r2 library do operation
+
+ Type : Public API
+
+ Usage: Task should invoke this function to execute the job with configuration.
+ This call will not wait till the job is finished.(non-blocking call)
+
+ Parameters: In/Out : b2r2_library :b2r2 library instance handler
+ In/Out : b2r2_configuration :b2r2 library configuration
+
+*/
+
+
+void b2r2_library_do_operation(b2r2_library *library,b2r2_configuration *config
+ );
+
+
+/**
+
+ b2r2 library operation done
+
+ Type : Public API
+
+ Usage: Task should invoke this function to remove the job finshed with configuration.
+ This call will self-suspend the called task unless job is finished.(blocking call on suspend)
+
+ Parameters: In/Out : b2r2_library :b2r2 library instance handler
+ In/Out : b2r2_configuration :b2r2 library configuration
+
+*/
+
+void b2r2_library_operation_done(b2r2_library *library,b2r2_configuration *config);
+
+
+
+#ifdef __cplusplus
+}
+#endif /* _cplusplus */
+
+#endif /* !defined(__B2R2_API_H) */
+
diff --git a/b2r2_driver_usr_api.h b/b2r2_driver_usr_api.h
new file mode 100644
index 0000000..89f79cb
--- /dev/null
+++ b/b2r2_driver_usr_api.h
@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------*/
+/* © copyright STMicroelectronics(Wireless),2008. All rights reserved. For */
+/* information, STMicroelectronics(Wireless)reserves the right to license */
+/* this software concurrently under separate license conditions. */
+/* */
+/* This program is free software; you can redistribute it and/or modify it */
+/* under the terms of the GNU Lesser General Public License as published */
+/* by the Free Software Foundation; either version 2.1 of the License, */
+/* or (at your option)any later version. */
+/* */
+/* This program is distributed in the hope that it will be useful, but */
+/* WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See */
+/* the GNU Lesser General Public License for more details. */
+/* */
+/* You should have received a copy of the GNU Lesser General Public License */
+/* along with this program. If not, see <http://www.gnu.org/licenses/>. */
+/*---------------------------------------------------------------------------*/
+
+
+/**
+
+MODULE : B2R2 Device Driver
+
+FILE : b2r2_driver_usr_api.h
+
+DESCRIPTION : Defines application user interface for the B2R2 driver
+
+NOTES : User application using B2R2 driver should include this
+ file and use b2r2_driver instance.
+
+*/
+
+
+#ifndef __B2R2_DRIVER_USR_API
+#define __B2R2_DRIVER_USR_API
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* _cplusplus */
+
+
+#include <linux/ioctl.h>
+
+
+/**
+ * enum b2r2_driver_context - driver context
+ *
+ * description
+ * This enumeration is used for selecting in which
+ * b2r2 queue the job to be pushed.
+ *
+ */
+
+typedef enum b2r2_driver_context
+{
+
+B2R2_CQ1_JOB=0x1,
+B2R2_CQ2_JOB=0x2,
+B2R2_AQ1_JOB=0x4,
+B2R2_AQ2_JOB=0x8,
+B2R2_AQ3_JOB=0xc,
+B2R2_AQ4_JOB=0x10,
+B2R2_ERROR_JOB=0x20
+
+}b2r2_driver_context;
+
+/**
+ * struct b2r2_driver - Driver instance handler
+ * @context: b2r2 instance
+ * @jobid: job index
+ * @queue_address: Address of the queue
+ * @control: Control Params
+ * @pace_control: pace_control
+ * @interrupt_status: interrupt status
+ * @job_done: status of the job done
+ * @interrupt_target: interrupt target
+ * @interrupt_context: interrupt context
+ *
+ * description
+ * This structure is used for queuing and dequeueing a job.
+ * priority and type of hardware triggering can be selected.
+ *
+ */
+
+typedef struct b2r2_driver{
+
+ b2r2_driver_context context;
+ unsigned int jobid;
+
+ unsigned int queue_address;
+ unsigned int control;
+ unsigned int pace_control;
+ unsigned int interrupt_status;
+
+ unsigned int job_done;
+ unsigned int interrupt_target;
+ unsigned int interrupt_context;
+
+ }b2r2_driver;
+
+
+/**
+ * struct b2r2_driver_memory - Driver memory handler
+ * @physical_address: physical address of the memory
+ * @size_of_memory:size of the memory
+ *
+ * description
+ * This structure is used by to define the memory required.
+ *
+ */
+
+
+ typedef struct b2r2_driver_memory
+ {
+
+ unsigned int physical_address;
+ unsigned int size_of_memory;
+
+ }b2r2_driver_memory;
+
+
+/** Maximum size of the structure need to passed to B2R2 */
+
+#define B2R2_MAX_IOCTL_SIZE (4 * 1024)
+
+#define B2R2_IOC_MAGIC 0xcc
+
+
+/** INSTANCE SPECIFIC OPERATIONS */
+
+#define B2R2_QUEUE_JOB _IOWR(B2R2_IOC_MAGIC,1,b2r2_driver)
+#define B2R2_DEQUEUE_JOB _IOWR(B2R2_IOC_MAGIC,2,b2r2_driver)
+
+#define B2R2_ALLOCATE_MEMORY _IOWR(B2R2_IOC_MAGIC,4,b2r2_driver_memory)
+#define B2R2_DEALLOCATE_MEMORY _IOWR(B2R2_IOC_MAGIC,5,b2r2_driver_memory)
+
+#define B2R2_IOC_MAXNR (1)
+
+
+#ifdef _cplusplus
+}
+#endif /* _cplusplus */
+
+#endif //__B2R2_DRIVER_USR_API \ No newline at end of file
diff --git a/b2r2_global.h b/b2r2_global.h
new file mode 100644
index 0000000..b9d8d6e
--- /dev/null
+++ b/b2r2_global.h
@@ -0,0 +1,3606 @@
+/*---------------------------------------------------------------------------*/
+/* © copyright STMicroelectronics(Wireless),2008. All rights reserved. For */
+/* information, STMicroelectronics(Wireless)reserves the right to license */
+/* this software concurrently under separate license conditions. */
+/* */
+/* This program is free software; you can redistribute it and/or modify it */
+/* under the terms of the GNU Lesser General Public License as published */
+/* by the Free Software Foundation; either version 2.1 of the License, */
+/* or (at your option)any later version. */
+/* */
+/* This program is distributed in the hope that it will be useful, but */
+/* WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See */
+/* the GNU Lesser General Public License for more details. */
+/* */
+/* You should have received a copy of the GNU Lesser General Public License */
+/* along with this program. If not, see <http://www.gnu.org/licenses/>. */
+/*---------------------------------------------------------------------------*/
+
+
+
+#ifndef __B2R2_GLOBAL_H
+#define __B2R2_GLOBAL_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#define PITCH_1BYTE 0x1
+#define PITCH_2BYTE 0x2
+#define PITCH_3BYTE 0x3
+#define PITCH_4BYTE 0x4
+
+#define RESVD (0x00000000)
+#define NEXT_NODE_NULL (0x00000000)
+
+
+/* Register values */
+
+/* - BLT_SSBA17 */
+#define B2R2BLT_SSBA17SSBA17_bank_num (0xfc000000)
+#define B2R2BLT_SSBA17SSBA17_bank_numShift (0x1a)
+#define B2R2BLT_SSBA17SSBA17_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA17SSBA17_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA17Mask (0xffffffff)
+#define B2R2BLT_SSBA17TestMask (0xffffffff)
+#define B2R2BLT_SSBA17InitialValue (0x0)
+#define B2R2BLT_SSBA17AccessType (RW)
+#define B2R2BLT_SSBA17 (0x900)
+
+/* - BLT_SSBA18 */
+#define B2R2BLT_SSBA18SSBA18_bank_num (0xfc000000)
+#define B2R2BLT_SSBA18SSBA18_bank_numShift (0x1a)
+#define B2R2BLT_SSBA18SSBA18_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA18SSBA18_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA18Mask (0xffffffff)
+#define B2R2BLT_SSBA18TestMask (0xffffffff)
+#define B2R2BLT_SSBA18InitialValue (0x0)
+#define B2R2BLT_SSBA18AccessType (RW)
+#define B2R2BLT_SSBA18 (0x904)
+
+/* - BLT_SSBA19 */
+#define B2R2BLT_SSBA19SSBA19_bank_num (0xfc000000)
+#define B2R2BLT_SSBA19SSBA19_bank_numShift (0x1a)
+#define B2R2BLT_SSBA19SSBA19_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA19SSBA19_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA19Mask (0xffffffff)
+#define B2R2BLT_SSBA19TestMask (0xffffffff)
+#define B2R2BLT_SSBA19InitialValue (0x0)
+#define B2R2BLT_SSBA19AccessType (RW)
+#define B2R2BLT_SSBA19 (0x908)
+
+/* - BLT_SSBA20 */
+#define B2R2BLT_SSBA20SSBA20_bank_num (0xfc000000)
+#define B2R2BLT_SSBA20SSBA20_bank_numShift (0x1a)
+#define B2R2BLT_SSBA20SSBA20_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA20SSBA20_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA20Mask (0xffffffff)
+#define B2R2BLT_SSBA20TestMask (0xffffffff)
+#define B2R2BLT_SSBA20InitialValue (0x0)
+#define B2R2BLT_SSBA20AccessType (RW)
+#define B2R2BLT_SSBA20 (0x90c)
+
+/* - BLT_SSBA21 */
+#define B2R2BLT_SSBA21SSBA21_bank_num (0xfc000000)
+#define B2R2BLT_SSBA21SSBA21_bank_numShift (0x1a)
+#define B2R2BLT_SSBA21SSBA21_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA21SSBA21_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA21Mask (0xffffffff)
+#define B2R2BLT_SSBA21TestMask (0xffffffff)
+#define B2R2BLT_SSBA21InitialValue (0x0)
+#define B2R2BLT_SSBA21AccessType (RW)
+#define B2R2BLT_SSBA21 (0x910)
+
+/* - BLT_SSBA22 */
+#define B2R2BLT_SSBA22SSBA22_bank_num (0xfc000000)
+#define B2R2BLT_SSBA22SSBA22_bank_numShift (0x1a)
+#define B2R2BLT_SSBA22SSBA22_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA22SSBA22_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA22Mask (0xffffffff)
+#define B2R2BLT_SSBA22TestMask (0xffffffff)
+#define B2R2BLT_SSBA22InitialValue (0x0)
+#define B2R2BLT_SSBA22AccessType (RW)
+#define B2R2BLT_SSBA22 (0x914)
+
+/* - BLT_SSBA23 */
+#define B2R2BLT_SSBA23SSBA23_bank_num (0xfc000000)
+#define B2R2BLT_SSBA23SSBA23_bank_numShift (0x1a)
+#define B2R2BLT_SSBA23SSBA23_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA23SSBA23_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA23Mask (0xffffffff)
+#define B2R2BLT_SSBA23TestMask (0xffffffff)
+#define B2R2BLT_SSBA23InitialValue (0x0)
+#define B2R2BLT_SSBA23AccessType (RW)
+#define B2R2BLT_SSBA23 (0x918)
+
+/* - BLT_SSBA24 */
+#define B2R2BLT_SSBA24SSBA24_bank_num (0xfc000000)
+#define B2R2BLT_SSBA24SSBA24_bank_numShift (0x1a)
+#define B2R2BLT_SSBA24SSBA24_Mem_address (0x3ffffff)
+#define B2R2BLT_SSBA24SSBA24_Mem_addressShift (0x0)
+#define B2R2BLT_SSBA24Mask (0xffffffff)
+#define B2R2BLT_SSBA24TestMask (0xffffffff)
+#define B2R2BLT_SSBA24InitialValue (0x0)
+#define B2R2BLT_SSBA24AccessType (RW)
+#define B2R2BLT_SSBA24 (0x91c)
+
+/* - BLT_STBA5 */
+#define B2R2BLT_STBA5STBA5_bank_num (0xfc000000)
+#define B2R2BLT_STBA5STBA5_bank_numShift (0x1a)
+#define B2R2BLT_STBA5STBA5_Mem_address (0x3ffffff)
+#define B2R2BLT_STBA5STBA5_Mem_addressShift (0x0)
+#define B2R2BLT_STBA5Mask (0xffffffff)
+#define B2R2BLT_STBA5TestMask (0xffffffff)
+#define B2R2BLT_STBA5InitialValue (0x0)
+#define B2R2BLT_STBA5AccessType (RW)
+#define B2R2BLT_STBA5 (0x940)
+
+/* - BLT_STBA6 */
+#define B2R2BLT_STBA6STBA6_bank_num (0xfc000000)
+#define B2R2BLT_STBA6STBA6_bank_numShift (0x1a)
+#define B2R2BLT_STBA6STBA6_Mem_address (0x3ffffff)
+#define B2R2BLT_STBA6STBA6_Mem_addressShift (0x0)
+#define B2R2BLT_STBA6Mask (0xffffffff)
+#define B2R2BLT_STBA6TestMask (0xffffffff)
+#define B2R2BLT_STBA6InitialValue (0x0)
+#define B2R2BLT_STBA6AccessType (RW)
+#define B2R2BLT_STBA6 (0x944)
+
+/* - BLT_STBA7 */
+#define B2R2BLT_STBA7STBA7_bank_num (0xfc000000)
+#define B2R2BLT_STBA7STBA7_bank_numShift (0x1a)
+#define B2R2BLT_STBA7STBA7_Mem_address (0x3ffffff)
+#define B2R2BLT_STBA7STBA7_Mem_addressShift (0x0)
+#define B2R2BLT_STBA7Mask (0xffffffff)
+#define B2R2BLT_STBA7TestMask (0xffffffff)
+#define B2R2BLT_STBA7InitialValue (0x0)
+#define B2R2BLT_STBA7AccessType (RW)
+#define B2R2BLT_STBA7 (0x948)
+
+/* - BLT_STBA8 */
+#define B2R2BLT_STBA8STBA8_bank_num (0xfc000000)
+#define B2R2BLT_STBA8STBA8_bank_numShift (0x1a)
+#define B2R2BLT_STBA8STBA8_Mem_address (0x3ffffff)
+#define B2R2BLT_STBA8STBA8_Mem_addressShift (0x0)
+#define B2R2BLT_STBA8Mask (0xffffffff)
+#define B2R2BLT_STBA8TestMask (0xffffffff)
+#define B2R2BLT_STBA8InitialValue (0x0)
+#define B2R2BLT_STBA8AccessType (RW)
+#define B2R2BLT_STBA8 (0x94c)
+
+/* - BLT_CTL */
+#define B2R2BLT_CTLGLOBAL_soft_reset (0x80000000)
+#define B2R2BLT_CTLStep_By_Step (0x20000000)
+#define B2R2BLT_CTLBig_not_little (0x10000000)
+#define B2R2BLT_CTLMask (0xb0000000)
+#define B2R2BLT_CTLTestMask (0xb0000000)
+#define B2R2BLT_CTLInitialValue (0x0)
+#define B2R2BLT_CTLAccessType (INITIAL_TEST)
+#define B2R2BLT_CTL (0xa00)
+
+/* - BLT_ITS */
+#define B2R2BLT_ITSRLD_ERROR (0x80000000)
+#define B2R2BLT_ITSAQ4_Node_Notif (0x8000000)
+#define B2R2BLT_ITSAQ4_Node_repeat (0x4000000)
+#define B2R2BLT_ITSAQ4_Stopped (0x2000000)
+#define B2R2BLT_ITSAQ4_LNA_Reached (0x1000000)
+#define B2R2BLT_ITSAQ3_Node_Notif (0x800000)
+#define B2R2BLT_ITSAQ3_Node_repeat (0x400000)
+#define B2R2BLT_ITSAQ3_Stopped (0x200000)
+#define B2R2BLT_ITSAQ3_LNA_Reached (0x100000)
+#define B2R2BLT_ITSAQ2_Node_Notif (0x80000)
+#define B2R2BLT_ITSAQ2_Node_repeat (0x40000)
+#define B2R2BLT_ITSAQ2_Stopped (0x20000)
+#define B2R2BLT_ITSAQ2_LNA_Reached (0x10000)
+#define B2R2BLT_ITSAQ1_Node_Notif (0x8000)
+#define B2R2BLT_ITSAQ1_Node_repeat (0x4000)
+#define B2R2BLT_ITSAQ1_Stopped (0x2000)
+#define B2R2BLT_ITSAQ1_LNA_Reached (0x1000)
+#define B2R2BLT_ITSCQ2_Repaced (0x80)
+#define B2R2BLT_ITSCQ2_Node_Notif (0x40)
+#define B2R2BLT_ITSCQ2_retriggered (0x20)
+#define B2R2BLT_ITSCQ2_completed (0x10)
+#define B2R2BLT_ITSCQ1_Repaced (0x8)
+#define B2R2BLT_ITSCQ1_Node_Notif (0x4)
+#define B2R2BLT_ITSCQ1_retriggered (0x2)
+#define B2R2BLT_ITSCQ1_completed (0x1)
+#define B2R2BLT_ITSMask (0x8ffff0ff)
+#define B2R2BLT_ITSTestMask (0x8ffff0ff)
+#define B2R2BLT_ITSInitialValue (0x0)
+#define B2R2BLT_ITSAccessType (INITIAL_TEST)
+#define B2R2BLT_ITS (0xa04)
+
+/* - BLT_STA1 */
+#define B2R2BLT_STA1BDISP_IDLE (0x1)
+#define B2R2BLT_STA1Mask (0x1)
+#define B2R2BLT_STA1TestMask (0x1)
+#define B2R2BLT_STA1InitialValue (0x1)
+#define B2R2BLT_STA1AccessType (INITIAL_TEST)
+#define B2R2BLT_STA1 (0xa08)
+
+/* - BLT_SSBA1 */
+#define B2R2BLT_SSBA1SSBA1_bank_num (0xfc000000)
+#define B2R2BLT_SSBA1SSBA1_bank_numShift (0x1a)
+#define B2R2BLT_SSBA1SSBA1_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA1SSBA1_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA1Mask (0xffffffff)
+#define B2R2BLT_SSBA1TestMask (0xffffffff)
+#define B2R2BLT_SSBA1InitialValue (0x0)
+#define B2R2BLT_SSBA1AccessType (RW)
+#define B2R2BLT_SSBA1 (0xa10)
+
+/* - BLT_SSBA2 */
+#define B2R2BLT_SSBA2SSBA2_bank_num (0xfc000000)
+#define B2R2BLT_SSBA2SSBA2_bank_numShift (0x1a)
+#define B2R2BLT_SSBA2SSBA2_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA2SSBA2_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA2Mask (0xffffffff)
+#define B2R2BLT_SSBA2TestMask (0xffffffff)
+#define B2R2BLT_SSBA2InitialValue (0x0)
+#define B2R2BLT_SSBA2AccessType (RW)
+#define B2R2BLT_SSBA2 (0xa14)
+
+/* - BLT_SSBA3 */
+#define B2R2BLT_SSBA3SSBA3_bank_num (0xfc000000)
+#define B2R2BLT_SSBA3SSBA3_bank_numShift (0x1a)
+#define B2R2BLT_SSBA3SSBA3_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA3SSBA3_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA3Mask (0xffffffff)
+#define B2R2BLT_SSBA3TestMask (0xffffffff)
+#define B2R2BLT_SSBA3InitialValue (0x0)
+#define B2R2BLT_SSBA3AccessType (RW)
+#define B2R2BLT_SSBA3 (0xa18)
+
+/* - BLT_SSBA4 */
+#define B2R2BLT_SSBA4SSBA4_bank_num (0xfc000000)
+#define B2R2BLT_SSBA4SSBA4_bank_numShift (0x1a)
+#define B2R2BLT_SSBA4SSBA4_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA4SSBA4_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA4Mask (0xffffffff)
+#define B2R2BLT_SSBA4TestMask (0xffffffff)
+#define B2R2BLT_SSBA4InitialValue (0x0)
+#define B2R2BLT_SSBA4AccessType (RW)
+#define B2R2BLT_SSBA4 (0xa1c)
+
+/* - BLT_SSBA5 */
+#define B2R2BLT_SSBA5SSBA5_bank_num (0xfc000000)
+#define B2R2BLT_SSBA5SSBA5_bank_numShift (0x1a)
+#define B2R2BLT_SSBA5SSBA5_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA5SSBA5_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA5Mask (0xffffffff)
+#define B2R2BLT_SSBA5TestMask (0xffffffff)
+#define B2R2BLT_SSBA5InitialValue (0x0)
+#define B2R2BLT_SSBA5AccessType (RW)
+#define B2R2BLT_SSBA5 (0xa20)
+
+/* - BLT_SSBA6 */
+#define B2R2BLT_SSBA6SSBA6_bank_num (0xfc000000)
+#define B2R2BLT_SSBA6SSBA6_bank_numShift (0x1a)
+#define B2R2BLT_SSBA6SSBA6_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA6SSBA6_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA6Mask (0xffffffff)
+#define B2R2BLT_SSBA6TestMask (0xffffffff)
+#define B2R2BLT_SSBA6InitialValue (0x0)
+#define B2R2BLT_SSBA6AccessType (RW)
+#define B2R2BLT_SSBA6 (0xa24)
+
+/* - BLT_SSBA7 */
+#define B2R2BLT_SSBA7SSBA7_bank_num (0xfc000000)
+#define B2R2BLT_SSBA7SSBA7_bank_numShift (0x1a)
+#define B2R2BLT_SSBA7SSBA7_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA7SSBA7_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA7Mask (0xffffffff)
+#define B2R2BLT_SSBA7TestMask (0xffffffff)
+#define B2R2BLT_SSBA7InitialValue (0x0)
+#define B2R2BLT_SSBA7AccessType (RW)
+#define B2R2BLT_SSBA7 (0xa28)
+
+/* - BLT_SSBA8 */
+#define B2R2BLT_SSBA8SSBA8_bank_num (0xfc000000)
+#define B2R2BLT_SSBA8SSBA8_bank_numShift (0x1a)
+#define B2R2BLT_SSBA8SSBA8_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA8SSBA8_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA8Mask (0xffffffff)
+#define B2R2BLT_SSBA8TestMask (0xffffffff)
+#define B2R2BLT_SSBA8InitialValue (0x0)
+#define B2R2BLT_SSBA8AccessType (RW)
+#define B2R2BLT_SSBA8 (0xa2c)
+
+/* - BLT_STBA1 */
+#define B2R2BLT_STBA1STBA1_bank_num (0xfc000000)
+#define B2R2BLT_STBA1STBA1_bank_numShift (0x1a)
+#define B2R2BLT_STBA1STBA1_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_STBA1STBA1_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_STBA1Mask (0xffffffff)
+#define B2R2BLT_STBA1TestMask (0xffffffff)
+#define B2R2BLT_STBA1InitialValue (0x0)
+#define B2R2BLT_STBA1AccessType (RW)
+#define B2R2BLT_STBA1 (0xa30)
+
+/* - BLT_STBA2 */
+#define B2R2BLT_STBA2STBA2_bank_num (0xfc000000)
+#define B2R2BLT_STBA2STBA2_bank_numShift (0x1a)
+#define B2R2BLT_STBA2STBA2_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_STBA2STBA2_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_STBA2Mask (0xffffffff)
+#define B2R2BLT_STBA2TestMask (0xffffffff)
+#define B2R2BLT_STBA2InitialValue (0x0)
+#define B2R2BLT_STBA2AccessType (RW)
+#define B2R2BLT_STBA2 (0xa34)
+
+/* - BLT_STBA3 */
+#define B2R2BLT_STBA3STBA3_bank_num (0xfc000000)
+#define B2R2BLT_STBA3STBA3_bank_numShift (0x1a)
+#define B2R2BLT_STBA3STBA3_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_STBA3STBA3_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_STBA3Mask (0xffffffff)
+#define B2R2BLT_STBA3TestMask (0xffffffff)
+#define B2R2BLT_STBA3InitialValue (0x0)
+#define B2R2BLT_STBA3AccessType (RW)
+#define B2R2BLT_STBA3 (0xa38)
+
+/* - BLT_STBA4 */
+#define B2R2BLT_STBA4STBA4_bank_num (0xfc000000)
+#define B2R2BLT_STBA4STBA4_bank_numShift (0x1a)
+#define B2R2BLT_STBA4STBA4_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_STBA4STBA4_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_STBA4Mask (0xffffffff)
+#define B2R2BLT_STBA4TestMask (0xffffffff)
+#define B2R2BLT_STBA4InitialValue (0x0)
+#define B2R2BLT_STBA4AccessType (RW)
+#define B2R2BLT_STBA4 (0xa3c)
+
+/* - BLT_CQ1_TRIG_IP */
+#define B2R2BLT_CQ1_TRIG_IPTRIG_bank_num (0xfc000000)
+#define B2R2BLT_CQ1_TRIG_IPTRIG_bank_numShift (0x1a)
+#define B2R2BLT_CQ1_TRIG_IPCQ1_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_CQ1_TRIG_IPCQ1_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_CQ1_TRIG_IPMask (0xffffffff)
+#define B2R2BLT_CQ1_TRIG_IPTestMask (0xffffffff)
+#define B2R2BLT_CQ1_TRIG_IPInitialValue (0x0)
+#define B2R2BLT_CQ1_TRIG_IPAccessType (RW)
+#define B2R2BLT_CQ1_TRIG_IP (0xa40)
+
+/* - BLT_CQ1_TRIG_CTL */
+#define B2R2BLT_CQ1_TRIG_CTLQueue_en (0x80000000)
+#define B2R2BLT_CQ1_TRIG_CTLRetrig_behav (0xf000000)
+#define B2R2BLT_CQ1_TRIG_CTLRetrig_behavShift (0x18)
+#define B2R2BLT_CQ1_TRIG_CTLIRQ_mask (0xf00000)
+#define B2R2BLT_CQ1_TRIG_CTLIRQ_maskShift (0x14)
+#define B2R2BLT_CQ1_TRIG_CTLTrig_cond (0xf000)
+#define B2R2BLT_CQ1_TRIG_CTLTrig_condShift (0xc)
+#define B2R2BLT_CQ1_TRIG_CTLTrigger_line_num (0xfff)
+#define B2R2BLT_CQ1_TRIG_CTLTrigger_line_numShift (0x0)
+#define B2R2BLT_CQ1_TRIG_CTLMask (0x8ff0ffff)
+#define B2R2BLT_CQ1_TRIG_CTLTestMask (0x8ff0ffff)
+#define B2R2BLT_CQ1_TRIG_CTLInitialValue (0x0)
+#define B2R2BLT_CQ1_TRIG_CTLAccessType (INITIAL_TEST)
+#define B2R2BLT_CQ1_TRIG_CTL (0xa44)
+
+/* - BLT_CQ1_PACE_CTL */
+#define B2R2BLT_CQ1_PACE_CTLDynamic_Pace (0x80000000)
+#define B2R2BLT_CQ1_PACE_CTLPace_Count (0xfff0000)
+#define B2R2BLT_CQ1_PACE_CTLPace_CountShift (0x10)
+#define B2R2BLT_CQ1_PACE_CTLPace_start (0xfff)
+#define B2R2BLT_CQ1_PACE_CTLPace_startShift (0x0)
+#define B2R2BLT_CQ1_PACE_CTLMask (0x8fff0fff)
+#define B2R2BLT_CQ1_PACE_CTLTestMask (0x8ff0ffff)
+#define B2R2BLT_CQ1_PACE_CTLInitialValue (0x0)
+#define B2R2BLT_CQ1_PACE_CTLAccessType (INITIAL_TEST)
+#define B2R2BLT_CQ1_PACE_CTL (0xa48)
+
+/* - BLT_CQ1_IP */
+#define B2R2BLT_CQ1_IPInst_bank_num (0xfc000000)
+#define B2R2BLT_CQ1_IPInst_bank_numShift (0x1a)
+#define B2R2BLT_CQ1_IPInst_Memory_address (0x3ffffff)
+#define B2R2BLT_CQ1_IPInst_Memory_addressShift (0x0)
+#define B2R2BLT_CQ1_IPMask (0xffffffff)
+#define B2R2BLT_CQ1_IPTestMask (0xffffffff)
+#define B2R2BLT_CQ1_IPInitialValue (0x0)
+#define B2R2BLT_CQ1_IPAccessType (RO)
+#define B2R2BLT_CQ1_IP (0xa4c)
+
+/* - BLT_CQ2_TRIG_IP */
+#define B2R2BLT_CQ2_TRIG_IPTRIG_bank_num (0xfc000000)
+#define B2R2BLT_CQ2_TRIG_IPTRIG_bank_numShift (0x1a)
+#define B2R2BLT_CQ2_TRIG_IPCQ2_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_CQ2_TRIG_IPCQ2_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_CQ2_TRIG_IPMask (0xffffffff)
+#define B2R2BLT_CQ2_TRIG_IPTestMask (0xffffffff)
+#define B2R2BLT_CQ2_TRIG_IPInitialValue (0x0)
+#define B2R2BLT_CQ2_TRIG_IPAccessType (RW)
+#define B2R2BLT_CQ2_TRIG_IP (0xa50)
+
+/* - BLT_CQ2_TRIG_CTL */
+#define B2R2BLT_CQ2_TRIG_CTLQueue_en (0x80000000)
+#define B2R2BLT_CQ2_TRIG_CTLRetrig_behav (0xf000000)
+#define B2R2BLT_CQ2_TRIG_CTLRetrig_behavShift (0x18)
+#define B2R2BLT_CQ2_TRIG_CTLIRQ_mask (0xf00000)
+#define B2R2BLT_CQ2_TRIG_CTLIRQ_maskShift (0x14)
+#define B2R2BLT_CQ2_TRIG_CTLTrig_cond (0xf000)
+#define B2R2BLT_CQ2_TRIG_CTLTrig_condShift (0xc)
+#define B2R2BLT_CQ2_TRIG_CTLTrigger_line_num (0xfff)
+#define B2R2BLT_CQ2_TRIG_CTLTrigger_line_numShift (0x0)
+#define B2R2BLT_CQ2_TRIG_CTLMask (0x8ff0ffff)
+#define B2R2BLT_CQ2_TRIG_CTLTestMask (0x8ff0ffff)
+#define B2R2BLT_CQ2_TRIG_CTLInitialValue (0x0)
+#define B2R2BLT_CQ2_TRIG_CTLAccessType (INITIAL_TEST)
+#define B2R2BLT_CQ2_TRIG_CTL (0xa54)
+
+/* - BLT_CQ2_PACE_CTL */
+#define B2R2BLT_CQ2_PACE_CTLDynamic_Pace (0x80000000)
+#define B2R2BLT_CQ2_PACE_CTLPace_Count (0xfff0000)
+#define B2R2BLT_CQ2_PACE_CTLPace_CountShift (0x10)
+#define B2R2BLT_CQ2_PACE_CTLPace_start (0xfff)
+#define B2R2BLT_CQ2_PACE_CTLPace_startShift (0x0)
+#define B2R2BLT_CQ2_PACE_CTLMask (0x8fff0fff)
+#define B2R2BLT_CQ2_PACE_CTLTestMask (0x8ff0ffff)
+#define B2R2BLT_CQ2_PACE_CTLInitialValue (0x0)
+#define B2R2BLT_CQ2_PACE_CTLAccessType (INITIAL_TEST)
+#define B2R2BLT_CQ2_PACE_CTL (0xa58)
+
+/* - BLT_CQ2_IP */
+#define B2R2BLT_CQ2_IPInst_bank_num (0xfc000000)
+#define B2R2BLT_CQ2_IPInst_bank_numShift (0x1a)
+#define B2R2BLT_CQ2_IPInst_Memory_address (0x3ffffff)
+#define B2R2BLT_CQ2_IPInst_Memory_addressShift (0x0)
+#define B2R2BLT_CQ2_IPMask (0xffffffff)
+#define B2R2BLT_CQ2_IPTestMask (0xffffffff)
+#define B2R2BLT_CQ2_IPInitialValue (0x0)
+#define B2R2BLT_CQ2_IPAccessType (RO)
+#define B2R2BLT_CQ2_IP (0xa5c)
+
+/* - BLT_AQ1_CTL */
+#define B2R2BLT_AQ1_CTLQueue_en (0x80000000)
+#define B2R2BLT_AQ1_CTLEvent_behav (0x7000000)
+#define B2R2BLT_AQ1_CTLEvent_behavShift (0x18)
+#define B2R2BLT_AQ1_CTLIRQ_mask (0xf00000)
+#define B2R2BLT_AQ1_CTLIRQ_maskShift (0x14)
+#define B2R2BLT_AQ1_CTLPriority (0x3)
+#define B2R2BLT_AQ1_CTLPriorityShift (0x0)
+#define B2R2BLT_AQ1_CTLMask (0x87f00003)
+#define B2R2BLT_AQ1_CTLTestMask (0x87f00003)
+#define B2R2BLT_AQ1_CTLInitialValue (0x0)
+#define B2R2BLT_AQ1_CTLAccessType (INITIAL_TEST)
+#define B2R2BLT_AQ1_CTL (0xa60)
+
+/* - BLT_AQ1_IP */
+#define B2R2BLT_AQ1_IPInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ1_IPInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ1_IPinst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ1_IPinst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ1_IPMask (0xffffffff)
+#define B2R2BLT_AQ1_IPTestMask (0xffffffff)
+#define B2R2BLT_AQ1_IPInitialValue (0x0)
+#define B2R2BLT_AQ1_IPAccessType (RW)
+#define B2R2BLT_AQ1_IP (0xa64)
+
+/* - BLT_AQ1_LNA */
+#define B2R2BLT_AQ1_LNALna_bank_num (0xfc000000)
+#define B2R2BLT_AQ1_LNALna_bank_numShift (0x1a)
+#define B2R2BLT_AQ1_LNALna_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ1_LNALna_Memory_addressShift (0x0)
+#define B2R2BLT_AQ1_LNAMask (0xffffffff)
+#define B2R2BLT_AQ1_LNATestMask (0xffffffff)
+#define B2R2BLT_AQ1_LNAInitialValue (0x0)
+#define B2R2BLT_AQ1_LNAAccessType (RW)
+#define B2R2BLT_AQ1_LNA (0xa68)
+
+/* - BLT_AQ1_STA */
+#define B2R2BLT_AQ1_STAInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ1_STAInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ1_STAInst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ1_STAInst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ1_STAMask (0xffffffff)
+#define B2R2BLT_AQ1_STATestMask (0xffffffff)
+#define B2R2BLT_AQ1_STAInitialValue (0x0)
+#define B2R2BLT_AQ1_STAAccessType (RO)
+#define B2R2BLT_AQ1_STA (0xa6c)
+
+/* - BLT_AQ2_CTL */
+#define B2R2BLT_AQ2_CTLQueue_en (0x80000000)
+#define B2R2BLT_AQ2_CTLEvent_behav (0x7000000)
+#define B2R2BLT_AQ2_CTLEvent_behavShift (0x18)
+#define B2R2BLT_AQ2_CTLIRQ_mask (0xf00000)
+#define B2R2BLT_AQ2_CTLIRQ_maskShift (0x14)
+#define B2R2BLT_AQ2_CTLPriority (0x3)
+#define B2R2BLT_AQ2_CTLPriorityShift (0x0)
+#define B2R2BLT_AQ2_CTLMask (0x87f00003)
+#define B2R2BLT_AQ2_CTLTestMask (0x87f00003)
+#define B2R2BLT_AQ2_CTLInitialValue (0x0)
+#define B2R2BLT_AQ2_CTLAccessType (INITIAL_TEST)
+#define B2R2BLT_AQ2_CTL (0xa70)
+
+/* - BLT_AQ2_IP */
+#define B2R2BLT_AQ2_IPInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ2_IPInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ2_IPinst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ2_IPinst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ2_IPMask (0xffffffff)
+#define B2R2BLT_AQ2_IPTestMask (0xffffffff)
+#define B2R2BLT_AQ2_IPInitialValue (0x0)
+#define B2R2BLT_AQ2_IPAccessType (RW)
+#define B2R2BLT_AQ2_IP (0xa74)
+
+/* - BLT_AQ2_LNA */
+#define B2R2BLT_AQ2_LNALna_bank_num (0xfc000000)
+#define B2R2BLT_AQ2_LNALna_bank_numShift (0x1a)
+#define B2R2BLT_AQ2_LNALna_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ2_LNALna_Memory_addressShift (0x0)
+#define B2R2BLT_AQ2_LNAMask (0xffffffff)
+#define B2R2BLT_AQ2_LNATestMask (0xffffffff)
+#define B2R2BLT_AQ2_LNAInitialValue (0x0)
+#define B2R2BLT_AQ2_LNAAccessType (RW)
+#define B2R2BLT_AQ2_LNA (0xa78)
+
+/* - BLT_AQ2_STA */
+#define B2R2BLT_AQ2_STAInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ2_STAInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ2_STAInst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ2_STAInst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ2_STAMask (0xffffffff)
+#define B2R2BLT_AQ2_STATestMask (0xffffffff)
+#define B2R2BLT_AQ2_STAInitialValue (0x0)
+#define B2R2BLT_AQ2_STAAccessType (RO)
+#define B2R2BLT_AQ2_STA (0xa7c)
+
+/* - BLT_AQ3_CTL */
+#define B2R2BLT_AQ3_CTLQueue_en (0x80000000)
+#define B2R2BLT_AQ3_CTLEvent_behav (0x7000000)
+#define B2R2BLT_AQ3_CTLEvent_behavShift (0x18)
+#define B2R2BLT_AQ3_CTLIRQ_mask (0xf00000)
+#define B2R2BLT_AQ3_CTLIRQ_maskShift (0x14)
+#define B2R2BLT_AQ3_CTLPriority (0x3)
+#define B2R2BLT_AQ3_CTLPriorityShift (0x0)
+#define B2R2BLT_AQ3_CTLMask (0x87f00003)
+#define B2R2BLT_AQ3_CTLTestMask (0x87f00003)
+#define B2R2BLT_AQ3_CTLInitialValue (0x0)
+#define B2R2BLT_AQ3_CTLAccessType (NO_TEST)
+#define B2R2BLT_AQ3_CTL (0xa80)
+
+/* - BLT_AQ3_IP */
+#define B2R2BLT_AQ3_IPInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ3_IPInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ3_IPinst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ3_IPinst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ3_IPMask (0xffffffff)
+#define B2R2BLT_AQ3_IPTestMask (0xffffffff)
+#define B2R2BLT_AQ3_IPInitialValue (0x0)
+#define B2R2BLT_AQ3_IPAccessType (RW)
+#define B2R2BLT_AQ3_IP (0xa84)
+
+/* - BLT_AQ3_LNA */
+#define B2R2BLT_AQ3_LNALna_bank_num (0xfc000000)
+#define B2R2BLT_AQ3_LNALna_bank_numShift (0x1a)
+#define B2R2BLT_AQ3_LNALna_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ3_LNALna_Memory_addressShift (0x0)
+#define B2R2BLT_AQ3_LNAMask (0xffffffff)
+#define B2R2BLT_AQ3_LNATestMask (0xffffffff)
+#define B2R2BLT_AQ3_LNAInitialValue (0x0)
+#define B2R2BLT_AQ3_LNAAccessType (RW)
+#define B2R2BLT_AQ3_LNA (0xa88)
+
+/* - BLT_AQ3_STA */
+#define B2R2BLT_AQ3_STAInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ3_STAInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ3_STAInst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ3_STAInst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ3_STAMask (0xffffffff)
+#define B2R2BLT_AQ3_STATestMask (0xffffffff)
+#define B2R2BLT_AQ3_STAInitialValue (0x0)
+#define B2R2BLT_AQ3_STAAccessType (RO)
+#define B2R2BLT_AQ3_STA (0xa8c)
+
+/* - BLT_AQ4_CTL */
+#define B2R2BLT_AQ4_CTLQueue_en (0x80000000)
+#define B2R2BLT_AQ4_CTLEvent_behav (0x7000000)
+#define B2R2BLT_AQ4_CTLEvent_behavShift (0x18)
+#define B2R2BLT_AQ4_CTLIRQ_mask (0xf00000)
+#define B2R2BLT_AQ4_CTLIRQ_maskShift (0x14)
+#define B2R2BLT_AQ4_CTLPriority (0x3)
+#define B2R2BLT_AQ4_CTLPriorityShift (0x0)
+#define B2R2BLT_AQ4_CTLMask (0x87f00003)
+#define B2R2BLT_AQ4_CTLTestMask (0x87f00003)
+#define B2R2BLT_AQ4_CTLInitialValue (0x0)
+#define B2R2BLT_AQ4_CTLAccessType (NO_TEST)
+#define B2R2BLT_AQ4_CTL (0xa90)
+
+/* - BLT_AQ4_IP */
+#define B2R2BLT_AQ4_IPInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ4_IPInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ4_IPinst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ4_IPinst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ4_IPMask (0xffffffff)
+#define B2R2BLT_AQ4_IPTestMask (0xffffffff)
+#define B2R2BLT_AQ4_IPInitialValue (0x0)
+#define B2R2BLT_AQ4_IPAccessType (RW)
+#define B2R2BLT_AQ4_IP (0xa94)
+
+/* - BLT_AQ4_LNA */
+#define B2R2BLT_AQ4_LNALna_bank_num (0xfc000000)
+#define B2R2BLT_AQ4_LNALna_bank_numShift (0x1a)
+#define B2R2BLT_AQ4_LNALna_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ4_LNALna_Memory_addressShift (0x0)
+#define B2R2BLT_AQ4_LNAMask (0xffffffff)
+#define B2R2BLT_AQ4_LNATestMask (0xffffffff)
+#define B2R2BLT_AQ4_LNAInitialValue (0x0)
+#define B2R2BLT_AQ4_LNAAccessType (RW)
+#define B2R2BLT_AQ4_LNA (0xa98)
+
+/* - BLT_AQ4_STA */
+#define B2R2BLT_AQ4_STAInst_bank_num (0xfc000000)
+#define B2R2BLT_AQ4_STAInst_bank_numShift (0x1a)
+#define B2R2BLT_AQ4_STAInst_Memory_address (0x3ffffff)
+#define B2R2BLT_AQ4_STAInst_Memory_addressShift (0x0)
+#define B2R2BLT_AQ4_STAMask (0xffffffff)
+#define B2R2BLT_AQ4_STATestMask (0xffffffff)
+#define B2R2BLT_AQ4_STAInitialValue (0x0)
+#define B2R2BLT_AQ4_STAAccessType (RO)
+#define B2R2BLT_AQ4_STA (0xa9c)
+
+/* - BLT_SSBA9 */
+#define B2R2BLT_SSBA9SSBA9_bank_num (0xfc000000)
+#define B2R2BLT_SSBA9SSBA9_bank_numShift (0x1a)
+#define B2R2BLT_SSBA9SSBA9_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA9SSBA9_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA9Mask (0xffffffff)
+#define B2R2BLT_SSBA9TestMask (0xffffffff)
+#define B2R2BLT_SSBA9InitialValue (0x0)
+#define B2R2BLT_SSBA9AccessType (RW)
+#define B2R2BLT_SSBA9 (0xaa0)
+
+/* - BLT_SSBA10 */
+#define B2R2BLT_SSBA10SSBA10_bank_num (0xfc000000)
+#define B2R2BLT_SSBA10SSBA10_bank_numShift (0x1a)
+#define B2R2BLT_SSBA10SSBA10_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA10SSBA10_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA10Mask (0xffffffff)
+#define B2R2BLT_SSBA10TestMask (0xffffffff)
+#define B2R2BLT_SSBA10InitialValue (0x0)
+#define B2R2BLT_SSBA10AccessType (RW)
+#define B2R2BLT_SSBA10 (0xaa4)
+
+/* - BLT_SSBA11 */
+#define B2R2BLT_SSBA11SSBA11_bank_num (0xfc000000)
+#define B2R2BLT_SSBA11SSBA11_bank_numShift (0x1a)
+#define B2R2BLT_SSBA11SSBA11_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA11SSBA11_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA11Mask (0xffffffff)
+#define B2R2BLT_SSBA11TestMask (0xffffffff)
+#define B2R2BLT_SSBA11InitialValue (0x0)
+#define B2R2BLT_SSBA11AccessType (RW)
+#define B2R2BLT_SSBA11 (0xaa8)
+
+/* - BLT_SSBA12 */
+#define B2R2BLT_SSBA12SSBA12_bank_num (0xfc000000)
+#define B2R2BLT_SSBA12SSBA12_bank_numShift (0x1a)
+#define B2R2BLT_SSBA12SSBA12_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA12SSBA12_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA12Mask (0xffffffff)
+#define B2R2BLT_SSBA12TestMask (0xffffffff)
+#define B2R2BLT_SSBA12InitialValue (0x0)
+#define B2R2BLT_SSBA12AccessType (RW)
+#define B2R2BLT_SSBA12 (0xaac)
+
+/* - BLT_SSBA13 */
+#define B2R2BLT_SSBA13SSBA13_bank_num (0xfc000000)
+#define B2R2BLT_SSBA13SSBA13_bank_numShift (0x1a)
+#define B2R2BLT_SSBA13SSBA13_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA13SSBA13_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA13Mask (0xffffffff)
+#define B2R2BLT_SSBA13TestMask (0xffffffff)
+#define B2R2BLT_SSBA13InitialValue (0x0)
+#define B2R2BLT_SSBA13AccessType (RW)
+#define B2R2BLT_SSBA13 (0xab0)
+
+/* - BLT_SSBA14 */
+#define B2R2BLT_SSBA14SSBA14_bank_num (0xfc000000)
+#define B2R2BLT_SSBA14SSBA14_bank_numShift (0x1a)
+#define B2R2BLT_SSBA14SSBA14_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA14SSBA14_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA14Mask (0xffffffff)
+#define B2R2BLT_SSBA14TestMask (0xffffffff)
+#define B2R2BLT_SSBA14InitialValue (0x0)
+#define B2R2BLT_SSBA14AccessType (RW)
+#define B2R2BLT_SSBA14 (0xab4)
+
+/* - BLT_SSBA15 */
+#define B2R2BLT_SSBA15SSBA15_bank_num (0xfc000000)
+#define B2R2BLT_SSBA15SSBA15_bank_numShift (0x1a)
+#define B2R2BLT_SSBA15SSBA15_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA15SSBA15_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA15Mask (0xffffffff)
+#define B2R2BLT_SSBA15TestMask (0xffffffff)
+#define B2R2BLT_SSBA15InitialValue (0x0)
+#define B2R2BLT_SSBA15AccessType (RW)
+#define B2R2BLT_SSBA15 (0xab8)
+
+/* - BLT_SSBA16 */
+#define B2R2BLT_SSBA16SSBA16_bank_num (0xfc000000)
+#define B2R2BLT_SSBA16SSBA16_bank_numShift (0x1a)
+#define B2R2BLT_SSBA16SSBA16_MEMORY_ADDRESS (0x3ffffff)
+#define B2R2BLT_SSBA16SSBA16_MEMORY_ADDRESSShift (0x0)
+#define B2R2BLT_SSBA16Mask (0xffffffff)
+#define B2R2BLT_SSBA16TestMask (0xffffffff)
+#define B2R2BLT_SSBA16InitialValue (0x0)
+#define B2R2BLT_SSBA16AccessType (RW)
+#define B2R2BLT_SSBA16 (0xabc)
+
+/* - BLT_SGA1 */
+#define B2R2BLT_SGA1Alpha4 (0xff000000)
+#define B2R2BLT_SGA1Alpha4Shift (0x18)
+#define B2R2BLT_SGA1Alpha3 (0xff0000)
+#define B2R2BLT_SGA1Alpha3Shift (0x10)
+#define B2R2BLT_SGA1Alpha2 (0xff00)
+#define B2R2BLT_SGA1Alpha2Shift (0x8)
+#define B2R2BLT_SGA1Alpha1 (0xff)
+#define B2R2BLT_SGA1Alpha1Shift (0x0)
+#define B2R2BLT_SGA1Mask (0xffffffff)
+#define B2R2BLT_SGA1TestMask (0xffffffff)
+#define B2R2BLT_SGA1InitialValue (0x80808080)
+#define B2R2BLT_SGA1AccessType (RW)
+#define B2R2BLT_SGA1 (0xac0)
+
+/* - BLT_SGA2 */
+#define B2R2BLT_SGA2Alpha8 (0xff000000)
+#define B2R2BLT_SGA2Alpha8Shift (0x18)
+#define B2R2BLT_SGA2Alpha7 (0xff0000)
+#define B2R2BLT_SGA2Alpha7Shift (0x10)
+#define B2R2BLT_SGA2Alpha6 (0xff00)
+#define B2R2BLT_SGA2Alpha6Shift (0x8)
+#define B2R2BLT_SGA2Alpha5 (0xff)
+#define B2R2BLT_SGA2Alpha5Shift (0x0)
+#define B2R2BLT_SGA2Mask (0xffffffff)
+#define B2R2BLT_SGA2TestMask (0xffffffff)
+#define B2R2BLT_SGA2InitialValue (0x80808080)
+#define B2R2BLT_SGA2AccessType (RW)
+#define B2R2BLT_SGA2 (0xac4)
+
+/* - BLT_ITM0 */
+#define B2R2BLT_ITM0b31 (0x80000000)
+#define B2R2BLT_ITM0b27 (0x8000000)
+#define B2R2BLT_ITM0b26 (0x4000000)
+#define B2R2BLT_ITM0b25 (0x2000000)
+#define B2R2BLT_ITM0b24 (0x1000000)
+#define B2R2BLT_ITM0b23 (0x800000)
+#define B2R2BLT_ITM0b22 (0x400000)
+#define B2R2BLT_ITM0b21 (0x200000)
+#define B2R2BLT_ITM0b20 (0x100000)
+#define B2R2BLT_ITM0b19 (0x80000)
+#define B2R2BLT_ITM0b18 (0x40000)
+#define B2R2BLT_ITM0b17 (0x20000)
+#define B2R2BLT_ITM0b16 (0x10000)
+#define B2R2BLT_ITM0b15 (0x8000)
+#define B2R2BLT_ITM0b14 (0x4000)
+#define B2R2BLT_ITM0b13 (0x2000)
+#define B2R2BLT_ITM0b12 (0x1000)
+#define B2R2BLT_ITM0b7 (0x80)
+#define B2R2BLT_ITM0b6 (0x40)
+#define B2R2BLT_ITM0b5 (0x20)
+#define B2R2BLT_ITM0b4 (0x10)
+#define B2R2BLT_ITM0b3 (0x8)
+#define B2R2BLT_ITM0b2 (0x4)
+#define B2R2BLT_ITM0b1 (0x2)
+#define B2R2BLT_ITM0b0 (0x1)
+#define B2R2BLT_ITM0Mask (0x8ffff0ff)
+#define B2R2BLT_ITM0TestMask (0x8ffff0ff)
+#define B2R2BLT_ITM0InitialValue (0x0)
+#define B2R2BLT_ITM0AccessType (RW)
+#define B2R2BLT_ITM0 (0xad0)
+
+/* - BLT_ITM1 */
+#define B2R2BLT_ITM1b31 (0x80000000)
+#define B2R2BLT_ITM1b27 (0x8000000)
+#define B2R2BLT_ITM1b26 (0x4000000)
+#define B2R2BLT_ITM1b25 (0x2000000)
+#define B2R2BLT_ITM1b24 (0x1000000)
+#define B2R2BLT_ITM1b23 (0x800000)
+#define B2R2BLT_ITM1b22 (0x400000)
+#define B2R2BLT_ITM1b21 (0x200000)
+#define B2R2BLT_ITM1b20 (0x100000)
+#define B2R2BLT_ITM1b19 (0x80000)
+#define B2R2BLT_ITM1b18 (0x40000)
+#define B2R2BLT_ITM1b17 (0x20000)
+#define B2R2BLT_ITM1b16 (0x10000)
+#define B2R2BLT_ITM1b15 (0x8000)
+#define B2R2BLT_ITM1b14 (0x4000)
+#define B2R2BLT_ITM1b13 (0x2000)
+#define B2R2BLT_ITM1b12 (0x1000)
+#define B2R2BLT_ITM1b7 (0x80)
+#define B2R2BLT_ITM1b6 (0x40)
+#define B2R2BLT_ITM1b5 (0x20)
+#define B2R2BLT_ITM1b4 (0x10)
+#define B2R2BLT_ITM1b3 (0x8)
+#define B2R2BLT_ITM1b2 (0x4)
+#define B2R2BLT_ITM1b1 (0x2)
+#define B2R2BLT_ITM1b0 (0x1)
+#define B2R2BLT_ITM1Mask (0x8ffff0ff)
+#define B2R2BLT_ITM1TestMask (0x8ffff0ff)
+#define B2R2BLT_ITM1InitialValue (0x0)
+#define B2R2BLT_ITM1AccessType (RW)
+#define B2R2BLT_ITM1 (0xad4)
+
+/* - BLT_ITM2 */
+#define B2R2BLT_ITM2b31 (0x80000000)
+#define B2R2BLT_ITM2b27 (0x8000000)
+#define B2R2BLT_ITM2b26 (0x4000000)
+#define B2R2BLT_ITM2b25 (0x2000000)
+#define B2R2BLT_ITM2b24 (0x1000000)
+#define B2R2BLT_ITM2b23 (0x800000)
+#define B2R2BLT_ITM2b22 (0x400000)
+#define B2R2BLT_ITM2b21 (0x200000)
+#define B2R2BLT_ITM2b20 (0x100000)
+#define B2R2BLT_ITM2b19 (0x80000)
+#define B2R2BLT_ITM2b18 (0x40000)
+#define B2R2BLT_ITM2b17 (0x20000)
+#define B2R2BLT_ITM2b16 (0x10000)
+#define B2R2BLT_ITM2b15 (0x8000)
+#define B2R2BLT_ITM2b14 (0x4000)
+#define B2R2BLT_ITM2b13 (0x2000)
+#define B2R2BLT_ITM2b12 (0x1000)
+#define B2R2BLT_ITM2b7 (0x80)
+#define B2R2BLT_ITM2b6 (0x40)
+#define B2R2BLT_ITM2b5 (0x20)
+#define B2R2BLT_ITM2b4 (0x10)
+#define B2R2BLT_ITM2b3 (0x8)
+#define B2R2BLT_ITM2b2 (0x4)
+#define B2R2BLT_ITM2b1 (0x2)
+#define B2R2BLT_ITM2b0 (0x1)
+#define B2R2BLT_ITM2Mask (0x8ffff0ff)
+#define B2R2BLT_ITM2TestMask (0x8ffff0ff)
+#define B2R2BLT_ITM2InitialValue (0x0)
+#define B2R2BLT_ITM2AccessType (RW)
+#define B2R2BLT_ITM2 (0xad8)
+
+/* - BLT_ITM3 */
+#define B2R2BLT_ITM3b31 (0x80000000)
+#define B2R2BLT_ITM3b27 (0x8000000)
+#define B2R2BLT_ITM3b26 (0x4000000)
+#define B2R2BLT_ITM3b25 (0x2000000)
+#define B2R2BLT_ITM3b24 (0x1000000)
+#define B2R2BLT_ITM3b23 (0x800000)
+#define B2R2BLT_ITM3b22 (0x400000)
+#define B2R2BLT_ITM3b21 (0x200000)
+#define B2R2BLT_ITM3b20 (0x100000)
+#define B2R2BLT_ITM3b19 (0x80000)
+#define B2R2BLT_ITM3b18 (0x40000)
+#define B2R2BLT_ITM3b17 (0x20000)
+#define B2R2BLT_ITM3b16 (0x10000)
+#define B2R2BLT_ITM3b15 (0x8000)
+#define B2R2BLT_ITM3b14 (0x4000)
+#define B2R2BLT_ITM3b13 (0x2000)
+#define B2R2BLT_ITM3b12 (0x1000)
+#define B2R2BLT_ITM3b7 (0x80)
+#define B2R2BLT_ITM3b6 (0x40)
+#define B2R2BLT_ITM3b5 (0x20)
+#define B2R2BLT_ITM3b4 (0x10)
+#define B2R2BLT_ITM3b3 (0x8)
+#define B2R2BLT_ITM3b2 (0x4)
+#define B2R2BLT_ITM3b1 (0x2)
+#define B2R2BLT_ITM3b0 (0x1)
+#define B2R2BLT_ITM3Mask (0x8ffff0ff)
+#define B2R2BLT_ITM3TestMask (0x8ffff0ff)
+#define B2R2BLT_ITM3InitialValue (0x0)
+#define B2R2BLT_ITM3AccessType (RW)
+#define B2R2BLT_ITM3 (0xadc)
+
+/* - BLT_DFV2 */
+#define B2R2BLT_DFV2DFV2_Mode_En (0x80000000)
+#define B2R2BLT_DFV2DFV2_Vsync (0x40000000)
+#define B2R2BLT_DFV2DFV2_ntop_bot (0x20000000)
+#define B2R2BLT_DFV2DFV2_req (0x10000000)
+#define B2R2BLT_DFV2DFV2_Line_count (0xfff)
+#define B2R2BLT_DFV2DFV2_Line_countShift (0x0)
+#define B2R2BLT_DFV2Mask (0xf0000fff)
+#define B2R2BLT_DFV2TestMask (0xf0000fff)
+#define B2R2BLT_DFV2InitialValue (0x0)
+#define B2R2BLT_DFV2AccessType (NO_TEST)
+#define B2R2BLT_DFV2 (0xaf0)
+
+/* - BLT_DFV1 */
+#define B2R2BLT_DFV1DFV1_Mode_En (0x80000000)
+#define B2R2BLT_DFV1DFV1_Vsync (0x40000000)
+#define B2R2BLT_DFV1DFV1_ntop_bot (0x20000000)
+#define B2R2BLT_DFV1DFV1_req (0x10000000)
+#define B2R2BLT_DFV1DFV1_GPO (0x1000000)
+#define B2R2BLT_DFV1DFV1_CQ2_IT (0x200000)
+#define B2R2BLT_DFV1DFV1_CQ1_IT (0x100000)
+#define B2R2BLT_DFV1DFV1_AQ4_IT (0x80000)
+#define B2R2BLT_DFV1DFV1_AQ3_IT (0x40000)
+#define B2R2BLT_DFV1DFV1_AQ2_IT (0x20000)
+#define B2R2BLT_DFV1DFV1_AQ1_IT (0x10000)
+#define B2R2BLT_DFV1DFV1_ITM3_IT (0x8000)
+#define B2R2BLT_DFV1DFV1_ITM2_IT (0x4000)
+#define B2R2BLT_DFV1DFV1_ITM1_IT (0x2000)
+#define B2R2BLT_DFV1DFV1_ITM0_IT (0x1000)
+#define B2R2BLT_DFV1DFV1_Line_count (0xfff)
+#define B2R2BLT_DFV1DFV1_Line_countShift (0x0)
+#define B2R2BLT_DFV1Mask (0xf13fffff)
+#define B2R2BLT_DFV1TestMask (0xffffffff)
+#define B2R2BLT_DFV1InitialValue (0x0)
+#define B2R2BLT_DFV1AccessType (NO_TEST)
+#define B2R2BLT_DFV1 (0xaf4)
+
+/* - BLT_PRI */
+#define B2R2BLT_PRIAQ4_prio (0xf000000)
+#define B2R2BLT_PRIAQ4_prioShift (0x18)
+#define B2R2BLT_PRIAQ3_prio (0xf00000)
+#define B2R2BLT_PRIAQ3_prioShift (0x14)
+#define B2R2BLT_PRIAQ2_prio (0xf0000)
+#define B2R2BLT_PRIAQ2_prioShift (0x10)
+#define B2R2BLT_PRIAQ1_prio (0xf000)
+#define B2R2BLT_PRIAQ1_prioShift (0xc)
+#define B2R2BLT_PRICQ2_prio (0xf0)
+#define B2R2BLT_PRICQ2_prioShift (0x4)
+#define B2R2BLT_PRICQ1_prio (0xf)
+#define B2R2BLT_PRICQ1_prioShift (0x0)
+#define B2R2BLT_PRIMask (0xffff0ff)
+#define B2R2BLT_PRITestMask (0xfffffff)
+#define B2R2BLT_PRIInitialValue (0x0)
+#define B2R2BLT_PRIAccessType (INITIAL_TEST)
+#define B2R2BLT_PRI (0xaf8)
+
+/* - PLUGS1_OP2 */
+#define B2R2PLUGS1_OP2Max_opcode (0x7)
+#define B2R2PLUGS1_OP2Max_opcodeShift (0x0)
+#define B2R2PLUGS1_OP2Mask (0x7)
+#define B2R2PLUGS1_OP2TestMask (0x7)
+#define B2R2PLUGS1_OP2InitialValue (0x0)
+#define B2R2PLUGS1_OP2AccessType (RW)
+#define B2R2PLUGS1_OP2 (0xb04)
+
+/* - PLUGS1_CHZ */
+#define B2R2PLUGS1_CHZChunk_size (0x7)
+#define B2R2PLUGS1_CHZChunk_sizeShift (0x0)
+#define B2R2PLUGS1_CHZMask (0x7)
+#define B2R2PLUGS1_CHZTestMask (0x7)
+#define B2R2PLUGS1_CHZInitialValue (0x0)
+#define B2R2PLUGS1_CHZAccessType (RW)
+#define B2R2PLUGS1_CHZ (0xb08)
+
+/* - PLUGS1_MSZ */
+#define B2R2PLUGS1_MSZMinSpaceBetweenReq (0xffff0000)
+#define B2R2PLUGS1_MSZMinSpaceBetweenReqShift (0x10)
+#define B2R2PLUGS1_MSZMessage_Size (0x7)
+#define B2R2PLUGS1_MSZMessage_SizeShift (0x0)
+#define B2R2PLUGS1_MSZMask (0xffff0007)
+#define B2R2PLUGS1_MSZTestMask (0xffff0007)
+#define B2R2PLUGS1_MSZInitialValue (0x0)
+#define B2R2PLUGS1_MSZAccessType (RW)
+#define B2R2PLUGS1_MSZ (0xb0c)
+
+/* - PLUGS1_PGZ */
+#define B2R2PLUGS1_PGZPage_size (0xf)
+#define B2R2PLUGS1_PGZPage_sizeShift (0x0)
+#define B2R2PLUGS1_PGZMask (0xf)
+#define B2R2PLUGS1_PGZTestMask (0xf)
+#define B2R2PLUGS1_PGZInitialValue (0x0)
+#define B2R2PLUGS1_PGZAccessType (RW)
+#define B2R2PLUGS1_PGZ (0xb10)
+
+/* - PLUGS2_OP2 */
+#define B2R2PLUGS2_OP2Max_opcode (0x7)
+#define B2R2PLUGS2_OP2Max_opcodeShift (0x0)
+#define B2R2PLUGS2_OP2Mask (0x7)
+#define B2R2PLUGS2_OP2TestMask (0x7)
+#define B2R2PLUGS2_OP2InitialValue (0x0)
+#define B2R2PLUGS2_OP2AccessType (RW)
+#define B2R2PLUGS2_OP2 (0xb24)
+
+/* - PLUGS2_CHZ */
+#define B2R2PLUGS2_CHZChunk_size (0x7)
+#define B2R2PLUGS2_CHZChunk_sizeShift (0x0)
+#define B2R2PLUGS2_CHZMask (0x7)
+#define B2R2PLUGS2_CHZTestMask (0x7)
+#define B2R2PLUGS2_CHZInitialValue (0x0)
+#define B2R2PLUGS2_CHZAccessType (RW)
+#define B2R2PLUGS2_CHZ (0xb28)
+
+/* - PLUGS2_MSZ */
+#define B2R2PLUGS2_MSZMinSpaceBetweenReq (0xffff0000)
+#define B2R2PLUGS2_MSZMinSpaceBetweenReqShift (0x10)
+#define B2R2PLUGS2_MSZMessage_Size (0x7)
+#define B2R2PLUGS2_MSZMessage_SizeShift (0x0)
+#define B2R2PLUGS2_MSZMask (0xffff0007)
+#define B2R2PLUGS2_MSZTestMask (0xffff0007)
+#define B2R2PLUGS2_MSZInitialValue (0x0)
+#define B2R2PLUGS2_MSZAccessType (RW)
+#define B2R2PLUGS2_MSZ (0xb2c)
+
+/* - PLUGS2_PGZ */
+#define B2R2PLUGS2_PGZPage_size (0xf)
+#define B2R2PLUGS2_PGZPage_sizeShift (0x0)
+#define B2R2PLUGS2_PGZMask (0xf)
+#define B2R2PLUGS2_PGZTestMask (0xf)
+#define B2R2PLUGS2_PGZInitialValue (0x0)
+#define B2R2PLUGS2_PGZAccessType (RW)
+#define B2R2PLUGS2_PGZ (0xb30)
+
+/* - PLUGS3_OP2 */
+#define B2R2PLUGS3_OP2Max_opcode (0x7)
+#define B2R2PLUGS3_OP2Max_opcodeShift (0x0)
+#define B2R2PLUGS3_OP2Mask (0x7)
+#define B2R2PLUGS3_OP2TestMask (0x7)
+#define B2R2PLUGS3_OP2InitialValue (0x0)
+#define B2R2PLUGS3_OP2AccessType (RW)
+#define B2R2PLUGS3_OP2 (0xb44)
+
+/* - PLUGS3_CHZ */
+#define B2R2PLUGS3_CHZChunk_size (0x7)
+#define B2R2PLUGS3_CHZChunk_sizeShift (0x0)
+#define B2R2PLUGS3_CHZMask (0x7)
+#define B2R2PLUGS3_CHZTestMask (0x7)
+#define B2R2PLUGS3_CHZInitialValue (0x0)
+#define B2R2PLUGS3_CHZAccessType (RW)
+#define B2R2PLUGS3_CHZ (0xb48)
+
+/* - PLUGS3_MSZ */
+#define B2R2PLUGS3_MSZMinSpaceBetweenReq (0xffff0000)
+#define B2R2PLUGS3_MSZMinSpaceBetweenReqShift (0x10)
+#define B2R2PLUGS3_MSZMessage_Size (0x7)
+#define B2R2PLUGS3_MSZMessage_SizeShift (0x0)
+#define B2R2PLUGS3_MSZMask (0xffff0007)
+#define B2R2PLUGS3_MSZTestMask (0xffff0007)
+#define B2R2PLUGS3_MSZInitialValue (0x0)
+#define B2R2PLUGS3_MSZAccessType (RW)
+#define B2R2PLUGS3_MSZ (0xb4c)
+
+/* - PLUGS3_PGZ */
+#define B2R2PLUGS3_PGZPage_size (0xf)
+#define B2R2PLUGS3_PGZPage_sizeShift (0x0)
+#define B2R2PLUGS3_PGZMask (0xf)
+#define B2R2PLUGS3_PGZTestMask (0xf)
+#define B2R2PLUGS3_PGZInitialValue (0x0)
+#define B2R2PLUGS3_PGZAccessType (RW)
+#define B2R2PLUGS3_PGZ (0xb50)
+
+/* - PLUGT_OP2 */
+#define B2R2PLUGT_OP2Max_code (0x7)
+#define B2R2PLUGT_OP2Max_codeShift (0x0)
+#define B2R2PLUGT_OP2Mask (0x7)
+#define B2R2PLUGT_OP2TestMask (0x7)
+#define B2R2PLUGT_OP2InitialValue (0x0)
+#define B2R2PLUGT_OP2AccessType (RW)
+#define B2R2PLUGT_OP2 (0xb84)
+
+/* - PLUGT_CHZ */
+#define B2R2PLUGT_CHZChunk_size (0x7)
+#define B2R2PLUGT_CHZChunk_sizeShift (0x0)
+#define B2R2PLUGT_CHZMask (0x7)
+#define B2R2PLUGT_CHZTestMask (0x7)
+#define B2R2PLUGT_CHZInitialValue (0x0)
+#define B2R2PLUGT_CHZAccessType (RW)
+#define B2R2PLUGT_CHZ (0xb88)
+
+/* - PLUGT_MSZ */
+#define B2R2PLUGT_MSZMinSpaceBetweenReq (0xffff0000)
+#define B2R2PLUGT_MSZMinSpaceBetweenReqShift (0x10)
+#define B2R2PLUGT_MSZMessage_size (0x7)
+#define B2R2PLUGT_MSZMessage_sizeShift (0x0)
+#define B2R2PLUGT_MSZMask (0xffff0007)
+#define B2R2PLUGT_MSZTestMask (0xffff0007)
+#define B2R2PLUGT_MSZInitialValue (0x0)
+#define B2R2PLUGT_MSZAccessType (RW)
+#define B2R2PLUGT_MSZ (0xb8c)
+
+/* - PLUGT_PGZ */
+#define B2R2PLUGT_PGZPage_size (0xf)
+#define B2R2PLUGT_PGZPage_sizeShift (0x0)
+#define B2R2PLUGT_PGZMask (0xf)
+#define B2R2PLUGT_PGZTestMask (0xf)
+#define B2R2PLUGT_PGZInitialValue (0x0)
+#define B2R2PLUGT_PGZAccessType (RW)
+#define B2R2PLUGT_PGZ (0xb90)
+
+/* - BLT_NIP */
+#define B2R2BLT_NIPNIP_BANK_NUM (0xfc000000)
+#define B2R2BLT_NIPNIP_BANK_NUMShift (0x1a)
+#define B2R2BLT_NIPNIP_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_NIPNIP_MEM_ADDRShift (0x0)
+#define B2R2BLT_NIPMask (0xffffffff)
+#define B2R2BLT_NIPTestMask (0xffffffff)
+#define B2R2BLT_NIPInitialValue (0x0)
+#define B2R2BLT_NIPAccessType (INITIAL_TEST)
+#define B2R2BLT_NIP (0xc00)
+
+/* - BLT_CIC */
+#define B2R2BLT_CICGroup18 (0x40000)
+#define B2R2BLT_CICGroup17 (0x20000)
+#define B2R2BLT_CICGroup16 (0x10000)
+#define B2R2BLT_CICGroup15 (0x8000)
+#define B2R2BLT_CICGroup14 (0x4000)
+#define B2R2BLT_CICGroup13 (0x2000)
+#define B2R2BLT_CICGroup12 (0x1000)
+#define B2R2BLT_CICGroup11 (0x800)
+#define B2R2BLT_CICGroup10 (0x400)
+#define B2R2BLT_CICGroup9 (0x200)
+#define B2R2BLT_CICGroup8 (0x100)
+#define B2R2BLT_CICGroup7 (0x80)
+#define B2R2BLT_CICGroup6 (0x40)
+#define B2R2BLT_CICGroup5 (0x20)
+#define B2R2BLT_CICGroup4 (0x10)
+#define B2R2BLT_CICGroup3 (0x8)
+#define B2R2BLT_CICGroup2 (0x4)
+#define B2R2BLT_CICMask (0x7fffc)
+#define B2R2BLT_CICTestMask (0x7fffc)
+#define B2R2BLT_CICInitialValue (0x0)
+#define B2R2BLT_CICAccessType (INITIAL_TEST)
+#define B2R2BLT_CIC (0xc04)
+
+/* - BLT_INS */
+#define B2R2BLT_INSBlitCompIRQ (0x80000000)
+#define B2R2BLT_INSPace_down (0x40000000)
+#define B2R2BLT_INSROTATION (0x40000)
+#define B2R2BLT_INSVC1R (0x20000)
+#define B2R2BLT_INSDOT (0x10000)
+#define B2R2BLT_INSXYL (0x8000)
+#define B2R2BLT_INSPLANE_MASK (0x4000)
+#define B2R2BLT_INSDEI (0x2000)
+#define B2R2BLT_INSOVMX (0x1000)
+#define B2R2BLT_INSCKEY (0x800)
+#define B2R2BLT_INSRECT_CLIP (0x400)
+#define B2R2BLT_INSFILCK_FILT (0x200)
+#define B2R2BLT_INS2DRESCALE (0x100)
+#define B2R2BLT_INSCLUTOP (0x80)
+#define B2R2BLT_INSIVMX (0x40)
+#define B2R2BLT_INSSOURCE3 (0x20)
+#define B2R2BLT_INSSOURCE2 (0x18)
+#define B2R2BLT_INSSOURCE2Shift (0x3)
+#define B2R2BLT_INSSOURCE1 (0x7)
+#define B2R2BLT_INSSOURCE1Shift (0x0)
+#define B2R2BLT_INSMask (0xc007ffff)
+#define B2R2BLT_INSTestMask (0xc001ffff)
+#define B2R2BLT_INSInitialValue (0x0)
+#define B2R2BLT_INSAccessType (INITIAL_TEST)
+#define B2R2BLT_INS (0xc08)
+
+/* - BLT_ACK */
+#define B2R2BLT_ACKCKEY_SEL (0xc00000)
+#define B2R2BLT_ACKCKEY_SELShift (0x16)
+#define B2R2BLT_ACKACK_CKEY (0x3f0000)
+#define B2R2BLT_ACKACK_CKEYShift (0x10)
+#define B2R2BLT_ACKGALPHA_ROPID (0xff00)
+#define B2R2BLT_ACKGALPHA_ROPIDShift (0x8)
+#define B2R2BLT_ACKSWAP_FG_BG (0x10)
+#define B2R2BLT_ACKMODE (0xf)
+#define B2R2BLT_ACKMODEShift (0x0)
+#define B2R2BLT_ACKMask (0xffff1f)
+#define B2R2BLT_ACKTestMask (0xffff1f)
+#define B2R2BLT_ACKInitialValue (0x0)
+#define B2R2BLT_ACKAccessType (INITIAL_TEST)
+#define B2R2BLT_ACK (0xc0c)
+
+/* - BLT_TBA */
+#define B2R2BLT_TBATBA_bank_num (0xfc000000)
+#define B2R2BLT_TBATBA_bank_numShift (0x1a)
+#define B2R2BLT_TBATBA_mem_addr (0x3ffffff)
+#define B2R2BLT_TBATBA_mem_addrShift (0x0)
+#define B2R2BLT_TBAMask (0xffffffff)
+#define B2R2BLT_TBATestMask (0xffffffff)
+#define B2R2BLT_TBAInitialValue (0x0)
+#define B2R2BLT_TBAAccessType (INITIAL_TEST)
+#define B2R2BLT_TBA (0xc10)
+
+/* - BLT_TTY */
+#define B2R2BLT_TTYSecure (0x80000000)
+#define B2R2BLT_TTYBigNotLittle (0x40000000)
+#define B2R2BLT_TTYSUBBYTE (0x10000000)
+#define B2R2BLT_TTYCHROMA_notLUMA (0x8000000)
+#define B2R2BLT_TTYRGB_ROUND (0x4000000)
+#define B2R2BLT_TTYVSO (0x2000000)
+#define B2R2BLT_TTYHSO (0x1000000)
+#define B2R2BLT_TTYMB_FIELD (0x800000)
+#define B2R2BLT_TTYALPHA_RANGE (0x200000)
+#define B2R2BLT_TTYCOLOR_FORM (0x1f0000)
+#define B2R2BLT_TTYCOLOR_FORMShift (0x10)
+#define B2R2BLT_TTYPIXMAP_PITCH (0xffff)
+#define B2R2BLT_TTYPIXMAP_PITCHShift (0x0)
+#define B2R2BLT_TTYMask (0xdfbfffff)
+#define B2R2BLT_TTYTestMask (0xdf7fffff)
+#define B2R2BLT_TTYInitialValue (0x0)
+#define B2R2BLT_TTYAccessType (INITIAL_TEST)
+#define B2R2BLT_TTY (0xc14)
+
+/* - BLT_TXY */
+#define B2R2BLT_TXYYCOORD (0xffff0000)
+#define B2R2BLT_TXYYCOORDShift (0x10)
+#define B2R2BLT_TXYXCOORD (0xffff)
+#define B2R2BLT_TXYXCOORDShift (0x0)
+#define B2R2BLT_TXYMask (0xffffffff)
+#define B2R2BLT_TXYTestMask (0xffffffff)
+#define B2R2BLT_TXYInitialValue (0x0)
+#define B2R2BLT_TXYAccessType (INITIAL_TEST)
+#define B2R2BLT_TXY (0xc18)
+
+/* - BLT_TSZ */
+#define B2R2BLT_TSZWIN_HEIGHT (0xfff0000)
+#define B2R2BLT_TSZWIN_HEIGHTShift (0x10)
+#define B2R2BLT_TSZWIN_WIDTH (0xfff)
+#define B2R2BLT_TSZWIN_WIDTHShift (0x0)
+#define B2R2BLT_TSZMask (0xfff0fff)
+#define B2R2BLT_TSZTestMask (0xfffffff)
+#define B2R2BLT_TSZInitialValue (0x0)
+#define B2R2BLT_TSZAccessType (INITIAL_TEST)
+#define B2R2BLT_TSZ (0xc1c)
+
+/* - BLT_S1CF */
+#define B2R2BLT_S1CFSRC1_COLOR_FILL (0x0)
+#define B2R2BLT_S1CFSRC1_COLOR_FILLShift (0x0)
+#define B2R2BLT_S1CFMask (0x0)
+#define B2R2BLT_S1CFTestMask (0xffffffff)
+#define B2R2BLT_S1CFInitialValue (0x0)
+#define B2R2BLT_S1CFAccessType (INITIAL_TEST)
+#define B2R2BLT_S1CF (0xc20)
+
+/* - BLT_S2CF */
+#define B2R2BLT_S2CFSRC2_COLOR_FILL (0x0)
+#define B2R2BLT_S2CFSRC2_COLOR_FILLShift (0x0)
+#define B2R2BLT_S2CFMask (0x0)
+#define B2R2BLT_S2CFTestMask (0xffffffff)
+#define B2R2BLT_S2CFInitialValue (0x0)
+#define B2R2BLT_S2CFAccessType (INITIAL_TEST)
+#define B2R2BLT_S2CF (0xc24)
+
+/* - BLT_S1BA */
+#define B2R2BLT_S1BAS1BA_BANK_NUM (0xfc000000)
+#define B2R2BLT_S1BAS1BA_BANK_NUMShift (0x1a)
+#define B2R2BLT_S1BAS1BA_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_S1BAS1BA_MEM_ADDRShift (0x0)
+#define B2R2BLT_S1BAMask (0xffffffff)
+#define B2R2BLT_S1BATestMask (0xffffffff)
+#define B2R2BLT_S1BAInitialValue (0x0)
+#define B2R2BLT_S1BAAccessType (INITIAL_TEST)
+#define B2R2BLT_S1BA (0xc28)
+
+/* - BLT_S1TY */
+#define B2R2BLT_S1TYSecure (0x80000000)
+#define B2R2BLT_S1TYBigNotLittle (0x40000000)
+#define B2R2BLT_S1TYRGB_EXP (0x20000000)
+#define B2R2BLT_S1TYSUBBYTE (0x10000000)
+#define B2R2BLT_S1TYROTATION (0x8000000)
+#define B2R2BLT_S1TYVSO (0x2000000)
+#define B2R2BLT_S1TYHSO (0x1000000)
+#define B2R2BLT_S1TYA1_SUBST (0x400000)
+#define B2R2BLT_S1TYALPHA_RANGE (0x200000)
+#define B2R2BLT_S1TYCOLOR_FORM (0x1f0000)
+#define B2R2BLT_S1TYCOLOR_FORMShift (0x10)
+#define B2R2BLT_S1TYPIXMAP_PITCH (0xffff)
+#define B2R2BLT_S1TYPIXMAP_PITCHShift (0x0)
+#define B2R2BLT_S1TYMask (0xfb7fffff)
+#define B2R2BLT_S1TYTestMask (0xfb7fffff)
+#define B2R2BLT_S1TYInitialValue (0x0)
+#define B2R2BLT_S1TYAccessType (INITIAL_TEST)
+#define B2R2BLT_S1TY (0xc2c)
+
+/* - BLT_S1XY */
+#define B2R2BLT_S1XYYCOORD (0xffff0000)
+#define B2R2BLT_S1XYYCOORDShift (0x10)
+#define B2R2BLT_S1XYXCOORD (0xffff)
+#define B2R2BLT_S1XYXCOORDShift (0x0)
+#define B2R2BLT_S1XYMask (0xffffffff)
+#define B2R2BLT_S1XYTestMask (0xffffffff)
+#define B2R2BLT_S1XYInitialValue (0x0)
+#define B2R2BLT_S1XYAccessType (INITIAL_TEST)
+#define B2R2BLT_S1XY (0xc30)
+
+/* - BLT_S2BA */
+#define B2R2BLT_S2BAS2BA_BANK_NUM (0xfc000000)
+#define B2R2BLT_S2BAS2BA_BANK_NUMShift (0x1a)
+#define B2R2BLT_S2BAS2BA_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_S2BAS2BA_MEM_ADDRShift (0x0)
+#define B2R2BLT_S2BAMask (0xffffffff)
+#define B2R2BLT_S2BATestMask (0xffffffff)
+#define B2R2BLT_S2BAInitialValue (0x0)
+#define B2R2BLT_S2BAAccessType (INITIAL_TEST)
+#define B2R2BLT_S2BA (0xc38)
+
+/* - BLT_S2TY */
+#define B2R2BLT_S2TYSecure (0x80000000)
+#define B2R2BLT_S2TYBigNotLittle (0x40000000)
+#define B2R2BLT_S2TYRGB_EXP (0x20000000)
+#define B2R2BLT_S2TYSUBBYTE (0x10000000)
+#define B2R2BLT_S2TYCHROMA_LEFT (0x4000000)
+#define B2R2BLT_S2TYVSO (0x2000000)
+#define B2R2BLT_S2TYHSO (0x1000000)
+#define B2R2BLT_S2TYMB_FIELD (0x800000)
+#define B2R2BLT_S2TYA1_SUBST (0x400000)
+#define B2R2BLT_S2TYALPHA_RANGE (0x200000)
+#define B2R2BLT_S2TYCOLOR_FORM (0x1f0000)
+#define B2R2BLT_S2TYCOLOR_FORMShift (0x10)
+#define B2R2BLT_S2TYPIXMAP_PITCH (0xffff)
+#define B2R2BLT_S2TYPIXMAP_PITCHShift (0x0)
+#define B2R2BLT_S2TYMask (0xf7ffffff)
+#define B2R2BLT_S2TYTestMask (0xf7ffffff)
+#define B2R2BLT_S2TYInitialValue (0x0)
+#define B2R2BLT_S2TYAccessType (INITIAL_TEST)
+#define B2R2BLT_S2TY (0xc3c)
+
+/* - BLT_S2XY */
+#define B2R2BLT_S2XYYCOORD (0xffff0000)
+#define B2R2BLT_S2XYYCOORDShift (0x10)
+#define B2R2BLT_S2XYXCOORD (0xffff)
+#define B2R2BLT_S2XYXCOORDShift (0x0)
+#define B2R2BLT_S2XYMask (0xffffffff)
+#define B2R2BLT_S2XYTestMask (0xffffffff)
+#define B2R2BLT_S2XYInitialValue (0x0)
+#define B2R2BLT_S2XYAccessType (INITIAL_TEST)
+#define B2R2BLT_S2XY (0xc40)
+
+/* - BLT_S2SZ */
+#define B2R2BLT_S2SZSRC2_WIN_HEIGHT (0xfff0000)
+#define B2R2BLT_S2SZSRC2_WIN_HEIGHTShift (0x10)
+#define B2R2BLT_S2SZSRC2_WIN_WIDTH (0xfff)
+#define B2R2BLT_S2SZSRC2_WIN_WIDTHShift (0x0)
+#define B2R2BLT_S2SZMask (0xfff0fff)
+#define B2R2BLT_S2SZTestMask (0xfff0fff)
+#define B2R2BLT_S2SZInitialValue (0x0)
+#define B2R2BLT_S2SZAccessType (INITIAL_TEST)
+#define B2R2BLT_S2SZ (0xc44)
+
+/* - BLT_S2SZ */
+#define B2R2BLT_S2SZSRC2_WIN_HEIGHT (0xfff0000)
+#define B2R2BLT_S2SZSRC2_WIN_HEIGHTShift (0x10)
+#define B2R2BLT_S2SZSRC2_WIN_WIDTH (0xfff)
+#define B2R2BLT_S2SZSRC2_WIN_WIDTHShift (0x0)
+#define B2R2BLT_S2SZMask (0xfff0fff)
+#define B2R2BLT_S2SZTestMask (0xfff0fff)
+#define B2R2BLT_S2SZInitialValue (0x0)
+#define B2R2BLT_S2SZAccessType (INITIAL_TEST)
+#define B2R2BLT_S2SZ (0xc44)
+
+/* - BLT_S3BA */
+#define B2R2BLT_S3BAS3BA_bank_num (0xfc000000)
+#define B2R2BLT_S3BAS3BA_bank_numShift (0x1a)
+#define B2R2BLT_S3BAS3BA_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_S3BAS3BA_MEM_ADDRShift (0x0)
+#define B2R2BLT_S3BAMask (0xffffffff)
+#define B2R2BLT_S3BATestMask (0xffffffff)
+#define B2R2BLT_S3BAInitialValue (0x0)
+#define B2R2BLT_S3BAAccessType (INITIAL_TEST)
+#define B2R2BLT_S3BA (0xc48)
+
+/* - BLT_S3TY */
+#define B2R2BLT_S3TYSecure (0x80000000)
+#define B2R2BLT_S3TYHSO (0x2000000)
+#define B2R2BLT_S3TYVSO (0x1000000)
+#define B2R2BLT_S3TYMB_FIELD (0x800000)
+#define B2R2BLT_S3TYALPHA_RANGE (0x200000)
+#define B2R2BLT_S3TYCOLOR_FORM (0x1f0000)
+#define B2R2BLT_S3TYCOLOR_FORMShift (0x10)
+#define B2R2BLT_S3TYPIXMAP_PITCH (0xffff)
+#define B2R2BLT_S3TYPIXMAP_PITCHShift (0x0)
+#define B2R2BLT_S3TYMask (0x83bfffff)
+#define B2R2BLT_S3TYTestMask (0x83bfffff)
+#define B2R2BLT_S3TYInitialValue (0x0)
+#define B2R2BLT_S3TYAccessType (INITIAL_TEST)
+#define B2R2BLT_S3TY (0xc4c)
+
+/* - BLT_S3XY */
+#define B2R2BLT_S3XYYCOORD (0xffff0000)
+#define B2R2BLT_S3XYYCOORDShift (0x10)
+#define B2R2BLT_S3XYXCOORD (0xffff)
+#define B2R2BLT_S3XYXCOORDShift (0x0)
+#define B2R2BLT_S3XYMask (0xffffffff)
+#define B2R2BLT_S3XYTestMask (0xffffffff)
+#define B2R2BLT_S3XYInitialValue (0x0)
+#define B2R2BLT_S3XYAccessType (INITIAL_TEST)
+#define B2R2BLT_S3XY (0xc50)
+
+/* - BLT_S3SZ */
+#define B2R2BLT_S3SZSRC3_WIN_HEIGHT (0xfff0000)
+#define B2R2BLT_S3SZSRC3_WIN_HEIGHTShift (0x10)
+#define B2R2BLT_S3SZSRC3_WIN_WIDTH (0xfff)
+#define B2R2BLT_S3SZSRC3_WIN_WIDTHShift (0x0)
+#define B2R2BLT_S3SZMask (0xfff0fff)
+#define B2R2BLT_S3SZTestMask (0xfff0fff)
+#define B2R2BLT_S3SZInitialValue (0x0)
+#define B2R2BLT_S3SZAccessType (INITIAL_TEST)
+#define B2R2BLT_S3SZ (0xc54)
+
+/* - BLT_CWO */
+#define B2R2BLT_CWOINTNL (0x8000000)
+#define B2R2BLT_CWOYDO (0x7ff0000)
+#define B2R2BLT_CWOYDOShift (0x10)
+#define B2R2BLT_CWOXDO (0x7fff)
+#define B2R2BLT_CWOXDOShift (0x0)
+#define B2R2BLT_CWOMask (0xfff7fff)
+#define B2R2BLT_CWOTestMask (0xffff0fff)
+#define B2R2BLT_CWOInitialValue (0x0)
+#define B2R2BLT_CWOAccessType (INITIAL_TEST)
+#define B2R2BLT_CWO (0xc58)
+
+/* - BLT_CWS */
+#define B2R2BLT_CWSYDS (0x7ff0000)
+#define B2R2BLT_CWSYDSShift (0x10)
+#define B2R2BLT_CWSXDS (0x7fff)
+#define B2R2BLT_CWSXDSShift (0x0)
+#define B2R2BLT_CWSMask (0x7ff7fff)
+#define B2R2BLT_CWSTestMask (0xfff0fff)
+#define B2R2BLT_CWSInitialValue (0x0)
+#define B2R2BLT_CWSAccessType (INITIAL_TEST)
+#define B2R2BLT_CWS (0xc5c)
+
+/* - BLT_CCO */
+#define B2R2BLT_CCOCLUT_ERRDIFF (0x780000)
+#define B2R2BLT_CCOCLUT_ERRDIFFShift (0x13)
+#define B2R2BLT_CCOCLUT_UPDATE (0x40000)
+#define B2R2BLT_CCOCLUT_MODE (0x30000)
+#define B2R2BLT_CCOCLUT_MODEShift (0x10)
+#define B2R2BLT_CCOCLUT_NS2_1S1 (0x8000)
+#define B2R2BLT_CCOMask (0x7f8000)
+#define B2R2BLT_CCOTestMask (0x7f8000)
+#define B2R2BLT_CCOInitialValue (0x0)
+#define B2R2BLT_CCOAccessType (INITIAL_TEST)
+#define B2R2BLT_CCO (0xc60)
+
+/* - BLT_CML */
+#define B2R2BLT_CMLCML_BANK_NUM (0xfc000000)
+#define B2R2BLT_CMLCML_BANK_NUMShift (0x1a)
+#define B2R2BLT_CMLCML_MEM_ADDR (0x3fffff0)
+#define B2R2BLT_CMLCML_MEM_ADDRShift (0x4)
+#define B2R2BLT_CMLMask (0xfffffff0)
+#define B2R2BLT_CMLTestMask (0xfffffff0)
+#define B2R2BLT_CMLInitialValue (0x0)
+#define B2R2BLT_CMLAccessType (INITIAL_TEST)
+#define B2R2BLT_CML (0xc64)
+
+/* - BLT_FCTL */
+#define B2R2BLT_FCTLLuma_2Dvf_mode (0x30000000)
+#define B2R2BLT_FCTLLuma_2Dvf_modeShift (0x1c)
+#define B2R2BLT_FCTLLuma_2Dhf_mode (0x3000000)
+#define B2R2BLT_FCTLLuma_2Dhf_modeShift (0x18)
+#define B2R2BLT_FCTLAB_TOP (0x8000)
+#define B2R2BLT_FCTLAB_BOT (0x4000)
+#define B2R2BLT_FCTLAB_Left (0x2000)
+#define B2R2BLT_FCTLAB_Right (0x1000)
+#define B2R2BLT_FCTL2DVF_MODE (0x70)
+#define B2R2BLT_FCTL2DVF_MODEShift (0x4)
+#define B2R2BLT_FCTL2DHF_MODE (0x7)
+#define B2R2BLT_FCTL2DHF_MODEShift (0x0)
+#define B2R2BLT_FCTLMask (0x3300f077)
+#define B2R2BLT_FCTLTestMask (0xfffffff0)
+#define B2R2BLT_FCTLInitialValue (0x0)
+#define B2R2BLT_FCTLAccessType (INITIAL_TEST)
+#define B2R2BLT_FCTL (0xc68)
+
+/* - BLT_PMK */
+#define B2R2BLT_PMKPLANE_MASK (0x1)
+#define B2R2BLT_PMKMask (0x1)
+#define B2R2BLT_PMKTestMask (0xffffffff)
+#define B2R2BLT_PMKInitialValue (0x0)
+#define B2R2BLT_PMKAccessType (INITIAL_TEST)
+#define B2R2BLT_PMK (0xc6c)
+
+/* - BLT_RSF */
+#define B2R2BLT_RSFVSRC_INC (0xffff0000)
+#define B2R2BLT_RSFVSRC_INCShift (0x10)
+#define B2R2BLT_RSFHSRC_INC (0xffff)
+#define B2R2BLT_RSFHSRC_INCShift (0x0)
+#define B2R2BLT_RSFMask (0xffffffff)
+#define B2R2BLT_RSFTestMask (0xffffffff)
+#define B2R2BLT_RSFInitialValue (0x0)
+#define B2R2BLT_RSFAccessType (INITIAL_TEST)
+#define B2R2BLT_RSF (0xc70)
+
+/* - BLT_RZI */
+#define B2R2BLT_RZIVnb_repeat (0x70000000)
+#define B2R2BLT_RZIVnb_repeatShift (0x1c)
+#define B2R2BLT_RZIVSRC_INIT (0x3ff0000)
+#define B2R2BLT_RZIVSRC_INITShift (0x10)
+#define B2R2BLT_RZIHnb_repeat (0x7000)
+#define B2R2BLT_RZIHnb_repeatShift (0xc)
+#define B2R2BLT_RZIHSRC_INIT (0x3ff)
+#define B2R2BLT_RZIHSRC_INITShift (0x0)
+#define B2R2BLT_RZIMask (0x73ff73ff)
+#define B2R2BLT_RZITestMask (0x73ff73ff)
+#define B2R2BLT_RZIInitialValue (0x0)
+#define B2R2BLT_RZIAccessType (INITIAL_TEST)
+#define B2R2BLT_RZI (0xc74)
+
+/* - BLT_HFP */
+#define B2R2BLT_HFPHFP_BANK_NUM (0xfc000000)
+#define B2R2BLT_HFPHFP_BANK_NUMShift (0x1a)
+#define B2R2BLT_HFPHFP_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_HFPHFP_MEM_ADDRShift (0x0)
+#define B2R2BLT_HFPMask (0xffffffff)
+#define B2R2BLT_HFPTestMask (0xffffffff)
+#define B2R2BLT_HFPInitialValue (0x0)
+#define B2R2BLT_HFPAccessType (INITIAL_TEST)
+#define B2R2BLT_HFP (0xc78)
+
+/* - BLT_VFP */
+#define B2R2BLT_VFPVFP_BANK_NUM (0xfc000000)
+#define B2R2BLT_VFPVFP_BANK_NUMShift (0x1a)
+#define B2R2BLT_VFPVFP_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_VFPVFP_MEM_ADDRShift (0x0)
+#define B2R2BLT_VFPMask (0xffffffff)
+#define B2R2BLT_VFPTestMask (0xffffffff)
+#define B2R2BLT_VFPInitialValue (0x0)
+#define B2R2BLT_VFPAccessType (INITIAL_TEST)
+#define B2R2BLT_VFP (0xc7c)
+
+/* - BLT_Y_RSF */
+#define B2R2BLT_Y_RSFLuma_VSRC_INC (0xffff0000)
+#define B2R2BLT_Y_RSFLuma_VSRC_INCShift (0x10)
+#define B2R2BLT_Y_RSFLuma_HSRC_INC (0xffff)
+#define B2R2BLT_Y_RSFLuma_HSRC_INCShift (0x0)
+#define B2R2BLT_Y_RSFMask (0xffffffff)
+#define B2R2BLT_Y_RSFTestMask (0xffffffff)
+#define B2R2BLT_Y_RSFInitialValue (0x0)
+#define B2R2BLT_Y_RSFAccessType (INITIAL_TEST)
+#define B2R2BLT_Y_RSF (0xc80)
+
+/* - BLT_Y_RZI */
+#define B2R2BLT_Y_RZIVnb_repeat_Luma (0x70000000)
+#define B2R2BLT_Y_RZIVnb_repeat_LumaShift (0x1c)
+#define B2R2BLT_Y_RZIVsrc_init_luma (0x3ff0000)
+#define B2R2BLT_Y_RZIVsrc_init_lumaShift (0x10)
+#define B2R2BLT_Y_RZIHnb_repeat_luma (0x7000)
+#define B2R2BLT_Y_RZIHnb_repeat_lumaShift (0xc)
+#define B2R2BLT_Y_RZIHsrc_init_luma (0x3ff)
+#define B2R2BLT_Y_RZIHsrc_init_lumaShift (0x0)
+#define B2R2BLT_Y_RZIMask (0x73ff73ff)
+#define B2R2BLT_Y_RZITestMask (0x73ff73ff)
+#define B2R2BLT_Y_RZIInitialValue (0x0)
+#define B2R2BLT_Y_RZIAccessType (INITIAL_TEST)
+#define B2R2BLT_Y_RZI (0xc84)
+
+/* - BLT_Y_HFP */
+#define B2R2BLT_Y_HFPY_Hfp_Bank_num (0xfc000000)
+#define B2R2BLT_Y_HFPY_Hfp_Bank_numShift (0x1a)
+#define B2R2BLT_Y_HFPY_HFP_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_Y_HFPY_HFP_MEM_ADDRShift (0x0)
+#define B2R2BLT_Y_HFPMask (0xffffffff)
+#define B2R2BLT_Y_HFPTestMask (0xffffffff)
+#define B2R2BLT_Y_HFPInitialValue (0x0)
+#define B2R2BLT_Y_HFPAccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFP (0xc88)
+
+/* - BLT_Y_VFP */
+#define B2R2BLT_Y_VFPY_Vfp_Bank_num (0xfc000000)
+#define B2R2BLT_Y_VFPY_Vfp_Bank_numShift (0x1a)
+#define B2R2BLT_Y_VFPY_VFP_MEM_ADDR (0x3ffffff)
+#define B2R2BLT_Y_VFPY_VFP_MEM_ADDRShift (0x0)
+#define B2R2BLT_Y_VFPMask (0xffffffff)
+#define B2R2BLT_Y_VFPTestMask (0xffffffff)
+#define B2R2BLT_Y_VFPInitialValue (0x0)
+#define B2R2BLT_Y_VFPAccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFP (0xc8c)
+
+/* - BLT_KEY1 */
+#define B2R2BLT_KEY1ALPHA0 (0xff000000)
+#define B2R2BLT_KEY1ALPHA0Shift (0x18)
+#define B2R2BLT_KEY1RED_MIN (0xff0000)
+#define B2R2BLT_KEY1RED_MINShift (0x10)
+#define B2R2BLT_KEY1GREEN_MIN (0xff00)
+#define B2R2BLT_KEY1GREEN_MINShift (0x8)
+#define B2R2BLT_KEY1BLUE_MIN (0xff)
+#define B2R2BLT_KEY1BLUE_MINShift (0x0)
+#define B2R2BLT_KEY1Mask (0xffffffff)
+#define B2R2BLT_KEY1TestMask (0xfffffff)
+#define B2R2BLT_KEY1InitialValue (0x0)
+#define B2R2BLT_KEY1AccessType (INITIAL_TEST)
+#define B2R2BLT_KEY1 (0xca0)
+
+/* - BLT_KEY2 */
+#define B2R2BLT_KEY2ALPHA1 (0xff000000)
+#define B2R2BLT_KEY2ALPHA1Shift (0x18)
+#define B2R2BLT_KEY2RED_MAX (0xff0000)
+#define B2R2BLT_KEY2RED_MAXShift (0x10)
+#define B2R2BLT_KEY2GREEN_MAX (0xff00)
+#define B2R2BLT_KEY2GREEN_MAXShift (0x8)
+#define B2R2BLT_KEY2BLUE_MAX (0xff)
+#define B2R2BLT_KEY2BLUE_MAXShift (0x0)
+#define B2R2BLT_KEY2Mask (0xffffffff)
+#define B2R2BLT_KEY2TestMask (0xfffffff)
+#define B2R2BLT_KEY2InitialValue (0x0)
+#define B2R2BLT_KEY2AccessType (INITIAL_TEST)
+#define B2R2BLT_KEY2 (0xca4)
+
+/* - BLT_SAR */
+#define B2R2BLT_SARA_SGA (0xf0000000)
+#define B2R2BLT_SARA_SGAShift (0x1c)
+#define B2R2BLT_SART_STBA (0xf000000)
+#define B2R2BLT_SART_STBAShift (0x18)
+#define B2R2BLT_SARS3_SSBA (0x1f0000)
+#define B2R2BLT_SARS3_SSBAShift (0x10)
+#define B2R2BLT_SARS2_SSBA (0x1f00)
+#define B2R2BLT_SARS2_SSBAShift (0x8)
+#define B2R2BLT_SARS1_SSBA (0x1f)
+#define B2R2BLT_SARS1_SSBAShift (0x0)
+#define B2R2BLT_SARMask (0xff1f1f1f)
+#define B2R2BLT_SARTestMask (0xf71f0f1f)
+#define B2R2BLT_SARInitialValue (0x0)
+#define B2R2BLT_SARAccessType (INITIAL_TEST)
+#define B2R2BLT_SAR (0xcb0)
+
+/* - BLT_USR */
+#define B2R2BLT_USRGENERAL_PURPOSE (0x0)
+#define B2R2BLT_USRGENERAL_PURPOSEShift (0x0)
+#define B2R2BLT_USRMask (0x0)
+#define B2R2BLT_USRTestMask (0xffffffff)
+#define B2R2BLT_USRInitialValue (0x0)
+#define B2R2BLT_USRAccessType (INITIAL_TEST)
+#define B2R2BLT_USR (0xcb4)
+
+/* - BLT_IVMX0 */
+#define B2R2BLT_IVMX0Coeff11 (0xffe00000)
+#define B2R2BLT_IVMX0Coeff11Shift (0x15)
+#define B2R2BLT_IVMX0Coeff12 (0x1ffc00)
+#define B2R2BLT_IVMX0Coeff12Shift (0xa)
+#define B2R2BLT_IVMX0Coeff13 (0x3ff)
+#define B2R2BLT_IVMX0Coeff13Shift (0x0)
+#define B2R2BLT_IVMX0Mask (0xffffffff)
+#define B2R2BLT_IVMX0TestMask (0xffffffff)
+#define B2R2BLT_IVMX0InitialValue (0x0)
+#define B2R2BLT_IVMX0AccessType (INITIAL_TEST)
+#define B2R2BLT_IVMX0 (0xcc0)
+
+/* - BLT_IVMX1 */
+#define B2R2BLT_IVMX1Coeff21 (0xffe00000)
+#define B2R2BLT_IVMX1Coeff21Shift (0x15)
+#define B2R2BLT_IVMX1Coeff22 (0x1ffc00)
+#define B2R2BLT_IVMX1Coeff22Shift (0xa)
+#define B2R2BLT_IVMX1Coeff23 (0x3ff)
+#define B2R2BLT_IVMX1Coeff23Shift (0x0)
+#define B2R2BLT_IVMX1Mask (0xffffffff)
+#define B2R2BLT_IVMX1TestMask (0xffffffff)
+#define B2R2BLT_IVMX1InitialValue (0x0)
+#define B2R2BLT_IVMX1AccessType (INITIAL_TEST)
+#define B2R2BLT_IVMX1 (0xcc4)
+
+/* - BLT_IVMX2 */
+#define B2R2BLT_IVMX2Coeff31 (0xffe00000)
+#define B2R2BLT_IVMX2Coeff31Shift (0x15)
+#define B2R2BLT_IVMX2Coeff32 (0x1ffc00)
+#define B2R2BLT_IVMX2Coeff32Shift (0xa)
+#define B2R2BLT_IVMX2Coeff33 (0x3ff)
+#define B2R2BLT_IVMX2Coeff33Shift (0x0)
+#define B2R2BLT_IVMX2Mask (0xffffffff)
+#define B2R2BLT_IVMX2TestMask (0xffffffff)
+#define B2R2BLT_IVMX2InitialValue (0x0)
+#define B2R2BLT_IVMX2AccessType (INITIAL_TEST)
+#define B2R2BLT_IVMX2 (0xcc8)
+
+/* - BLT_IVMX3 */
+#define B2R2BLT_IVMX3Offset1 (0x3ff00000)
+#define B2R2BLT_IVMX3Offset1Shift (0x14)
+#define B2R2BLT_IVMX3Offset2 (0xffc00)
+#define B2R2BLT_IVMX3Offset2Shift (0xa)
+#define B2R2BLT_IVMX3Offset3 (0x3ff)
+#define B2R2BLT_IVMX3Offset3Shift (0x0)
+#define B2R2BLT_IVMX3Mask (0x3fffffff)
+#define B2R2BLT_IVMX3TestMask (0x3fffffff)
+#define B2R2BLT_IVMX3InitialValue (0x0)
+#define B2R2BLT_IVMX3AccessType (INITIAL_TEST)
+#define B2R2BLT_IVMX3 (0xccc)
+
+/* - BLT_OVMX0 */
+#define B2R2BLT_OVMX0Coeff11 (0xffe00000)
+#define B2R2BLT_OVMX0Coeff11Shift (0x15)
+#define B2R2BLT_OVMX0Coeff12 (0x1ffc00)
+#define B2R2BLT_OVMX0Coeff12Shift (0xa)
+#define B2R2BLT_OVMX0Coeff13 (0x3ff)
+#define B2R2BLT_OVMX0Coeff13Shift (0x0)
+#define B2R2BLT_OVMX0Mask (0xffffffff)
+#define B2R2BLT_OVMX0TestMask (0x3fffffff)
+#define B2R2BLT_OVMX0InitialValue (0x0)
+#define B2R2BLT_OVMX0AccessType (INITIAL_TEST)
+#define B2R2BLT_OVMX0 (0xcd0)
+
+/* - BLT_OVMX1 */
+#define B2R2BLT_OVMX1Coeff21 (0xffe00000)
+#define B2R2BLT_OVMX1Coeff21Shift (0x15)
+#define B2R2BLT_OVMX1Coeff22 (0x1ffc00)
+#define B2R2BLT_OVMX1Coeff22Shift (0xa)
+#define B2R2BLT_OVMX1Coeff23 (0x3ff)
+#define B2R2BLT_OVMX1Coeff23Shift (0x0)
+#define B2R2BLT_OVMX1Mask (0xffffffff)
+#define B2R2BLT_OVMX1TestMask (0xffffffff)
+#define B2R2BLT_OVMX1InitialValue (0x0)
+#define B2R2BLT_OVMX1AccessType (INITIAL_TEST)
+#define B2R2BLT_OVMX1 (0xcd4)
+
+/* - BLT_OVMX2 */
+#define B2R2BLT_OVMX2Coeff31 (0xffe00000)
+#define B2R2BLT_OVMX2Coeff31Shift (0x15)
+#define B2R2BLT_OVMX2Coeff32 (0x1ffc00)
+#define B2R2BLT_OVMX2Coeff32Shift (0xa)
+#define B2R2BLT_OVMX2Coeff33 (0x3ff)
+#define B2R2BLT_OVMX2Coeff33Shift (0x0)
+#define B2R2BLT_OVMX2Mask (0xffffffff)
+#define B2R2BLT_OVMX2TestMask (0xffffffff)
+#define B2R2BLT_OVMX2InitialValue (0x0)
+#define B2R2BLT_OVMX2AccessType (INITIAL_TEST)
+#define B2R2BLT_OVMX2 (0xcd8)
+
+/* - BLT_OVMX3 */
+#define B2R2BLT_OVMX3Offset1 (0x3ff00000)
+#define B2R2BLT_OVMX3Offset1Shift (0x14)
+#define B2R2BLT_OVMX3Offset2 (0xffc00)
+#define B2R2BLT_OVMX3Offset2Shift (0xa)
+#define B2R2BLT_OVMX3Offset3 (0x3ff)
+#define B2R2BLT_OVMX3Offset3Shift (0x0)
+#define B2R2BLT_OVMX3Mask (0x3fffffff)
+#define B2R2BLT_OVMX3TestMask (0x3fffffff)
+#define B2R2BLT_OVMX3InitialValue (0x0)
+#define B2R2BLT_OVMX3AccessType (INITIAL_TEST)
+#define B2R2BLT_OVMX3 (0xcdc)
+
+/* - BLT_VC1R */
+#define B2R2BLT_VC1RChroma_map (0x80)
+#define B2R2BLT_VC1RChroma_coeff (0x70)
+#define B2R2BLT_VC1RChroma_coeffShift (0x4)
+#define B2R2BLT_VC1RLuma_Map (0x8)
+#define B2R2BLT_VC1RLuma_coeff (0x7)
+#define B2R2BLT_VC1RLuma_coeffShift (0x0)
+#define B2R2BLT_VC1RMask (0xff)
+#define B2R2BLT_VC1RTestMask (0xff)
+#define B2R2BLT_VC1RInitialValue (0x0)
+#define B2R2BLT_VC1RAccessType (INITIAL_TEST)
+#define B2R2BLT_VC1R (0xce8)
+
+/* - BLT_Y_HFC0 */
+#define B2R2BLT_Y_HFC0K3 (0xff000000)
+#define B2R2BLT_Y_HFC0K3Shift (0x18)
+#define B2R2BLT_Y_HFC0K2 (0xff0000)
+#define B2R2BLT_Y_HFC0K2Shift (0x10)
+#define B2R2BLT_Y_HFC0K1 (0xff00)
+#define B2R2BLT_Y_HFC0K1Shift (0x8)
+#define B2R2BLT_Y_HFC0K0 (0xff)
+#define B2R2BLT_Y_HFC0K0Shift (0x0)
+#define B2R2BLT_Y_HFC0Mask (0xffffffff)
+#define B2R2BLT_Y_HFC0TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC0InitialValue (0x0)
+#define B2R2BLT_Y_HFC0AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC0 (0xd00)
+
+/* - BLT_Y_HFC1 */
+#define B2R2BLT_Y_HFC1K7 (0xff000000)
+#define B2R2BLT_Y_HFC1K7Shift (0x18)
+#define B2R2BLT_Y_HFC1K6 (0xff0000)
+#define B2R2BLT_Y_HFC1K6Shift (0x10)
+#define B2R2BLT_Y_HFC1K5 (0xff00)
+#define B2R2BLT_Y_HFC1K5Shift (0x8)
+#define B2R2BLT_Y_HFC1K4 (0xff)
+#define B2R2BLT_Y_HFC1K4Shift (0x0)
+#define B2R2BLT_Y_HFC1Mask (0xffffffff)
+#define B2R2BLT_Y_HFC1TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC1InitialValue (0x0)
+#define B2R2BLT_Y_HFC1AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC1 (0xd04)
+
+/* - BLT_Y_HFC2 */
+#define B2R2BLT_Y_HFC2K13 (0xff000000)
+#define B2R2BLT_Y_HFC2K13Shift (0x18)
+#define B2R2BLT_Y_HFC2K12 (0xff0000)
+#define B2R2BLT_Y_HFC2K12Shift (0x10)
+#define B2R2BLT_Y_HFC2K11 (0xff00)
+#define B2R2BLT_Y_HFC2K11Shift (0x8)
+#define B2R2BLT_Y_HFC2K10 (0xff)
+#define B2R2BLT_Y_HFC2K10Shift (0x0)
+#define B2R2BLT_Y_HFC2Mask (0xffffffff)
+#define B2R2BLT_Y_HFC2TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC2InitialValue (0x0)
+#define B2R2BLT_Y_HFC2AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC2 (0xd08)
+
+/* - BLT_Y_HFC3 */
+#define B2R2BLT_Y_HFC3K17 (0xff000000)
+#define B2R2BLT_Y_HFC3K17Shift (0x18)
+#define B2R2BLT_Y_HFC3K16 (0xff0000)
+#define B2R2BLT_Y_HFC3K16Shift (0x10)
+#define B2R2BLT_Y_HFC3K15 (0xff00)
+#define B2R2BLT_Y_HFC3K15Shift (0x8)
+#define B2R2BLT_Y_HFC3K14 (0xff)
+#define B2R2BLT_Y_HFC3K14Shift (0x0)
+#define B2R2BLT_Y_HFC3Mask (0xffffffff)
+#define B2R2BLT_Y_HFC3TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC3InitialValue (0x0)
+#define B2R2BLT_Y_HFC3AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC3 (0xd0c)
+
+/* - BLT_Y_HFC4 */
+#define B2R2BLT_Y_HFC4K23 (0xff000000)
+#define B2R2BLT_Y_HFC4K23Shift (0x18)
+#define B2R2BLT_Y_HFC4K22 (0xff0000)
+#define B2R2BLT_Y_HFC4K22Shift (0x10)
+#define B2R2BLT_Y_HFC4K21 (0xff00)
+#define B2R2BLT_Y_HFC4K21Shift (0x8)
+#define B2R2BLT_Y_HFC4K20 (0xff)
+#define B2R2BLT_Y_HFC4K20Shift (0x0)
+#define B2R2BLT_Y_HFC4Mask (0xffffffff)
+#define B2R2BLT_Y_HFC4TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC4InitialValue (0x0)
+#define B2R2BLT_Y_HFC4AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC4 (0xd10)
+
+/* - BLT_Y_HFC5 */
+#define B2R2BLT_Y_HFC5K27 (0xff000000)
+#define B2R2BLT_Y_HFC5K27Shift (0x18)
+#define B2R2BLT_Y_HFC5K26 (0xff0000)
+#define B2R2BLT_Y_HFC5K26Shift (0x10)
+#define B2R2BLT_Y_HFC5K25 (0xff00)
+#define B2R2BLT_Y_HFC5K25Shift (0x8)
+#define B2R2BLT_Y_HFC5K24 (0xff)
+#define B2R2BLT_Y_HFC5K24Shift (0x0)
+#define B2R2BLT_Y_HFC5Mask (0xffffffff)
+#define B2R2BLT_Y_HFC5TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC5InitialValue (0x0)
+#define B2R2BLT_Y_HFC5AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC5 (0xd14)
+
+/* - BLT_Y_HFC6 */
+#define B2R2BLT_Y_HFC6K33 (0xff000000)
+#define B2R2BLT_Y_HFC6K33Shift (0x18)
+#define B2R2BLT_Y_HFC6K32 (0xff0000)
+#define B2R2BLT_Y_HFC6K32Shift (0x10)
+#define B2R2BLT_Y_HFC6K31 (0xff00)
+#define B2R2BLT_Y_HFC6K31Shift (0x8)
+#define B2R2BLT_Y_HFC6K30 (0xff)
+#define B2R2BLT_Y_HFC6K30Shift (0x0)
+#define B2R2BLT_Y_HFC6Mask (0xffffffff)
+#define B2R2BLT_Y_HFC6TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC6InitialValue (0x0)
+#define B2R2BLT_Y_HFC6AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC6 (0xd18)
+
+/* - BLT_Y_HFC7 */
+#define B2R2BLT_Y_HFC7K37 (0xff000000)
+#define B2R2BLT_Y_HFC7K37Shift (0x18)
+#define B2R2BLT_Y_HFC7K36 (0xff0000)
+#define B2R2BLT_Y_HFC7K36Shift (0x10)
+#define B2R2BLT_Y_HFC7K35 (0xff00)
+#define B2R2BLT_Y_HFC7K35Shift (0x8)
+#define B2R2BLT_Y_HFC7K34 (0xff)
+#define B2R2BLT_Y_HFC7K34Shift (0x0)
+#define B2R2BLT_Y_HFC7Mask (0xffffffff)
+#define B2R2BLT_Y_HFC7TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC7InitialValue (0x0)
+#define B2R2BLT_Y_HFC7AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC7 (0xd1c)
+
+/* - BLT_Y_HFC8 */
+#define B2R2BLT_Y_HFC8K43 (0xff000000)
+#define B2R2BLT_Y_HFC8K43Shift (0x18)
+#define B2R2BLT_Y_HFC8K42 (0xff0000)
+#define B2R2BLT_Y_HFC8K42Shift (0x10)
+#define B2R2BLT_Y_HFC8K41 (0xff00)
+#define B2R2BLT_Y_HFC8K41Shift (0x8)
+#define B2R2BLT_Y_HFC8K40 (0xff)
+#define B2R2BLT_Y_HFC8K40Shift (0x0)
+#define B2R2BLT_Y_HFC8Mask (0xffffffff)
+#define B2R2BLT_Y_HFC8TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC8InitialValue (0x0)
+#define B2R2BLT_Y_HFC8AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC8 (0xd20)
+
+/* - BLT_Y_HFC9 */
+#define B2R2BLT_Y_HFC9K47 (0xff000000)
+#define B2R2BLT_Y_HFC9K47Shift (0x18)
+#define B2R2BLT_Y_HFC9K46 (0xff0000)
+#define B2R2BLT_Y_HFC9K46Shift (0x10)
+#define B2R2BLT_Y_HFC9K45 (0xff00)
+#define B2R2BLT_Y_HFC9K45Shift (0x8)
+#define B2R2BLT_Y_HFC9K44 (0xff)
+#define B2R2BLT_Y_HFC9K44Shift (0x0)
+#define B2R2BLT_Y_HFC9Mask (0xffffffff)
+#define B2R2BLT_Y_HFC9TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC9InitialValue (0x0)
+#define B2R2BLT_Y_HFC9AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC9 (0xd24)
+
+/* - BLT_Y_HFC10 */
+#define B2R2BLT_Y_HFC10K53 (0xff000000)
+#define B2R2BLT_Y_HFC10K53Shift (0x18)
+#define B2R2BLT_Y_HFC10K52 (0xff0000)
+#define B2R2BLT_Y_HFC10K52Shift (0x10)
+#define B2R2BLT_Y_HFC10K51 (0xff00)
+#define B2R2BLT_Y_HFC10K51Shift (0x8)
+#define B2R2BLT_Y_HFC10K50 (0xff)
+#define B2R2BLT_Y_HFC10K50Shift (0x0)
+#define B2R2BLT_Y_HFC10Mask (0xffffffff)
+#define B2R2BLT_Y_HFC10TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC10InitialValue (0x0)
+#define B2R2BLT_Y_HFC10AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC10 (0xd28)
+
+/* - BLT_Y_HFC11 */
+#define B2R2BLT_Y_HFC11K57 (0xff000000)
+#define B2R2BLT_Y_HFC11K57Shift (0x18)
+#define B2R2BLT_Y_HFC11K56 (0xff0000)
+#define B2R2BLT_Y_HFC11K56Shift (0x10)
+#define B2R2BLT_Y_HFC11K55 (0xff00)
+#define B2R2BLT_Y_HFC11K55Shift (0x8)
+#define B2R2BLT_Y_HFC11K54 (0xff)
+#define B2R2BLT_Y_HFC11K54Shift (0x0)
+#define B2R2BLT_Y_HFC11Mask (0xffffffff)
+#define B2R2BLT_Y_HFC11TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC11InitialValue (0x0)
+#define B2R2BLT_Y_HFC11AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC11 (0xd2c)
+
+/* - BLT_Y_HFC12 */
+#define B2R2BLT_Y_HFC12K63 (0xff000000)
+#define B2R2BLT_Y_HFC12K63Shift (0x18)
+#define B2R2BLT_Y_HFC12K62 (0xff0000)
+#define B2R2BLT_Y_HFC12K62Shift (0x10)
+#define B2R2BLT_Y_HFC12K61 (0xff00)
+#define B2R2BLT_Y_HFC12K61Shift (0x8)
+#define B2R2BLT_Y_HFC12K60 (0xff)
+#define B2R2BLT_Y_HFC12K60Shift (0x0)
+#define B2R2BLT_Y_HFC12Mask (0xffffffff)
+#define B2R2BLT_Y_HFC12TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC12InitialValue (0x0)
+#define B2R2BLT_Y_HFC12AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC12 (0xd30)
+
+/* - BLT_Y_HFC13 */
+#define B2R2BLT_Y_HFC13K67 (0xff000000)
+#define B2R2BLT_Y_HFC13K67Shift (0x18)
+#define B2R2BLT_Y_HFC13K66 (0xff0000)
+#define B2R2BLT_Y_HFC13K66Shift (0x10)
+#define B2R2BLT_Y_HFC13K65 (0xff00)
+#define B2R2BLT_Y_HFC13K65Shift (0x8)
+#define B2R2BLT_Y_HFC13K64 (0xff)
+#define B2R2BLT_Y_HFC13K64Shift (0x0)
+#define B2R2BLT_Y_HFC13Mask (0xffffffff)
+#define B2R2BLT_Y_HFC13TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC13InitialValue (0x0)
+#define B2R2BLT_Y_HFC13AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC13 (0xd34)
+
+/* - BLT_Y_HFC14 */
+#define B2R2BLT_Y_HFC14K73 (0xff000000)
+#define B2R2BLT_Y_HFC14K73Shift (0x18)
+#define B2R2BLT_Y_HFC14K72 (0xff0000)
+#define B2R2BLT_Y_HFC14K72Shift (0x10)
+#define B2R2BLT_Y_HFC14K71 (0xff00)
+#define B2R2BLT_Y_HFC14K71Shift (0x8)
+#define B2R2BLT_Y_HFC14K70 (0xff)
+#define B2R2BLT_Y_HFC14K70Shift (0x0)
+#define B2R2BLT_Y_HFC14Mask (0xffffffff)
+#define B2R2BLT_Y_HFC14TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC14InitialValue (0x0)
+#define B2R2BLT_Y_HFC14AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC14 (0xd38)
+
+/* - BLT_Y_HFC15 */
+#define B2R2BLT_Y_HFC15K77 (0xff000000)
+#define B2R2BLT_Y_HFC15K77Shift (0x18)
+#define B2R2BLT_Y_HFC15K76 (0xff0000)
+#define B2R2BLT_Y_HFC15K76Shift (0x10)
+#define B2R2BLT_Y_HFC15K75 (0xff00)
+#define B2R2BLT_Y_HFC15K75Shift (0x8)
+#define B2R2BLT_Y_HFC15K74 (0xff)
+#define B2R2BLT_Y_HFC15K74Shift (0x0)
+#define B2R2BLT_Y_HFC15Mask (0xffffffff)
+#define B2R2BLT_Y_HFC15TestMask (0xffffffff)
+#define B2R2BLT_Y_HFC15InitialValue (0x0)
+#define B2R2BLT_Y_HFC15AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_HFC15 (0xd3c)
+
+/* - BLT_Y_VFC0 */
+#define B2R2BLT_Y_VFC0K3 (0xff000000)
+#define B2R2BLT_Y_VFC0K3Shift (0x18)
+#define B2R2BLT_Y_VFC0K2 (0xff0000)
+#define B2R2BLT_Y_VFC0K2Shift (0x10)
+#define B2R2BLT_Y_VFC0K1 (0xff00)
+#define B2R2BLT_Y_VFC0K1Shift (0x8)
+#define B2R2BLT_Y_VFC0K0 (0xff)
+#define B2R2BLT_Y_VFC0K0Shift (0x0)
+#define B2R2BLT_Y_VFC0Mask (0xffffffff)
+#define B2R2BLT_Y_VFC0TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC0InitialValue (0x0)
+#define B2R2BLT_Y_VFC0AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC0 (0xd90)
+
+/* - BLT_Y_VFC1 */
+#define B2R2BLT_Y_VFC1K12 (0xff000000)
+#define B2R2BLT_Y_VFC1K12Shift (0x18)
+#define B2R2BLT_Y_VFC1K11 (0xff0000)
+#define B2R2BLT_Y_VFC1K11Shift (0x10)
+#define B2R2BLT_Y_VFC1K10 (0xff00)
+#define B2R2BLT_Y_VFC1K10Shift (0x8)
+#define B2R2BLT_Y_VFC1K4 (0xff)
+#define B2R2BLT_Y_VFC1K4Shift (0x0)
+#define B2R2BLT_Y_VFC1Mask (0xffffffff)
+#define B2R2BLT_Y_VFC1TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC1InitialValue (0x0)
+#define B2R2BLT_Y_VFC1AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC1 (0xd94)
+
+/* - BLT_Y_VFC2 */
+#define B2R2BLT_Y_VFC2K21 (0xff000000)
+#define B2R2BLT_Y_VFC2K21Shift (0x18)
+#define B2R2BLT_Y_VFC2K20 (0xff0000)
+#define B2R2BLT_Y_VFC2K20Shift (0x10)
+#define B2R2BLT_Y_VFC2K14 (0xff00)
+#define B2R2BLT_Y_VFC2K14Shift (0x8)
+#define B2R2BLT_Y_VFC2K13 (0xff)
+#define B2R2BLT_Y_VFC2K13Shift (0x0)
+#define B2R2BLT_Y_VFC2Mask (0xffffffff)
+#define B2R2BLT_Y_VFC2TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC2InitialValue (0x0)
+#define B2R2BLT_Y_VFC2AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC2 (0xd98)
+
+/* - BLT_Y_VFC3 */
+#define B2R2BLT_Y_VFC3K30 (0xff000000)
+#define B2R2BLT_Y_VFC3K30Shift (0x18)
+#define B2R2BLT_Y_VFC3K24 (0xff0000)
+#define B2R2BLT_Y_VFC3K24Shift (0x10)
+#define B2R2BLT_Y_VFC3K23 (0xff00)
+#define B2R2BLT_Y_VFC3K23Shift (0x8)
+#define B2R2BLT_Y_VFC3K22 (0xff)
+#define B2R2BLT_Y_VFC3K22Shift (0x0)
+#define B2R2BLT_Y_VFC3Mask (0xffffffff)
+#define B2R2BLT_Y_VFC3TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC3InitialValue (0x0)
+#define B2R2BLT_Y_VFC3AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC3 (0xd9c)
+
+/* - BLT_Y_VFC4 */
+#define B2R2BLT_Y_VFC4K34 (0xff000000)
+#define B2R2BLT_Y_VFC4K34Shift (0x18)
+#define B2R2BLT_Y_VFC4K33 (0xff0000)
+#define B2R2BLT_Y_VFC4K33Shift (0x10)
+#define B2R2BLT_Y_VFC4K32 (0xff00)
+#define B2R2BLT_Y_VFC4K32Shift (0x8)
+#define B2R2BLT_Y_VFC4K31 (0xff)
+#define B2R2BLT_Y_VFC4K31Shift (0x0)
+#define B2R2BLT_Y_VFC4Mask (0xffffffff)
+#define B2R2BLT_Y_VFC4TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC4InitialValue (0x0)
+#define B2R2BLT_Y_VFC4AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC4 (0xda0)
+
+/* - BLT_Y_VFC5 */
+#define B2R2BLT_Y_VFC5K43 (0xff000000)
+#define B2R2BLT_Y_VFC5K43Shift (0x18)
+#define B2R2BLT_Y_VFC5K42 (0xff0000)
+#define B2R2BLT_Y_VFC5K42Shift (0x10)
+#define B2R2BLT_Y_VFC5K41 (0xff00)
+#define B2R2BLT_Y_VFC5K41Shift (0x8)
+#define B2R2BLT_Y_VFC5K40 (0xff)
+#define B2R2BLT_Y_VFC5K40Shift (0x0)
+#define B2R2BLT_Y_VFC5Mask (0xffffffff)
+#define B2R2BLT_Y_VFC5TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC5InitialValue (0x0)
+#define B2R2BLT_Y_VFC5AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC5 (0xda4)
+
+/* - BLT_Y_VFC6 */
+#define B2R2BLT_Y_VFC6K52 (0xff000000)
+#define B2R2BLT_Y_VFC6K52Shift (0x18)
+#define B2R2BLT_Y_VFC6K51 (0xff0000)
+#define B2R2BLT_Y_VFC6K51Shift (0x10)
+#define B2R2BLT_Y_VFC6K50 (0xff00)
+#define B2R2BLT_Y_VFC6K50Shift (0x8)
+#define B2R2BLT_Y_VFC6K44 (0xff)
+#define B2R2BLT_Y_VFC6K44Shift (0x0)
+#define B2R2BLT_Y_VFC6Mask (0xffffffff)
+#define B2R2BLT_Y_VFC6TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC6InitialValue (0x0)
+#define B2R2BLT_Y_VFC6AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC6 (0xda8)
+
+/* - BLT_Y_VFC7 */
+#define B2R2BLT_Y_VFC7K61 (0xff000000)
+#define B2R2BLT_Y_VFC7K61Shift (0x18)
+#define B2R2BLT_Y_VFC7K60 (0xff0000)
+#define B2R2BLT_Y_VFC7K60Shift (0x10)
+#define B2R2BLT_Y_VFC7K54 (0xff00)
+#define B2R2BLT_Y_VFC7K54Shift (0x8)
+#define B2R2BLT_Y_VFC7K53 (0xff)
+#define B2R2BLT_Y_VFC7K53Shift (0x0)
+#define B2R2BLT_Y_VFC7Mask (0xffffffff)
+#define B2R2BLT_Y_VFC7TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC7InitialValue (0x0)
+#define B2R2BLT_Y_VFC7AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC7 (0xdac)
+
+/* - BLT_Y_VFC8 */
+#define B2R2BLT_Y_VFC8K70 (0xff000000)
+#define B2R2BLT_Y_VFC8K70Shift (0x18)
+#define B2R2BLT_Y_VFC8K64 (0xff0000)
+#define B2R2BLT_Y_VFC8K64Shift (0x10)
+#define B2R2BLT_Y_VFC8K63 (0xff00)
+#define B2R2BLT_Y_VFC8K63Shift (0x8)
+#define B2R2BLT_Y_VFC8K62 (0xff)
+#define B2R2BLT_Y_VFC8K62Shift (0x0)
+#define B2R2BLT_Y_VFC8Mask (0xffffffff)
+#define B2R2BLT_Y_VFC8TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC8InitialValue (0x0)
+#define B2R2BLT_Y_VFC8AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC8 (0xdb0)
+
+/* - BLT_Y_VFC9 */
+#define B2R2BLT_Y_VFC9K74 (0xff000000)
+#define B2R2BLT_Y_VFC9K74Shift (0x18)
+#define B2R2BLT_Y_VFC9K73 (0xff0000)
+#define B2R2BLT_Y_VFC9K73Shift (0x10)
+#define B2R2BLT_Y_VFC9K72 (0xff00)
+#define B2R2BLT_Y_VFC9K72Shift (0x8)
+#define B2R2BLT_Y_VFC9K71 (0xff)
+#define B2R2BLT_Y_VFC9K71Shift (0x0)
+#define B2R2BLT_Y_VFC9Mask (0xffffffff)
+#define B2R2BLT_Y_VFC9TestMask (0xffffffff)
+#define B2R2BLT_Y_VFC9InitialValue (0x0)
+#define B2R2BLT_Y_VFC9AccessType (INITIAL_TEST)
+#define B2R2BLT_Y_VFC9 (0xdb4)
+
+/* - BLT_HFC0 */
+#define B2R2BLT_HFC0K3 (0xff000000)
+#define B2R2BLT_HFC0K3Shift (0x18)
+#define B2R2BLT_HFC0K2 (0xff0000)
+#define B2R2BLT_HFC0K2Shift (0x10)
+#define B2R2BLT_HFC0K1 (0xff00)
+#define B2R2BLT_HFC0K1Shift (0x8)
+#define B2R2BLT_HFC0K0 (0xff)
+#define B2R2BLT_HFC0K0Shift (0x0)
+#define B2R2BLT_HFC0Mask (0xffffffff)
+#define B2R2BLT_HFC0TestMask (0xffffffff)
+#define B2R2BLT_HFC0InitialValue (0x0)
+#define B2R2BLT_HFC0AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC0 (0xe00)
+
+/* - BLT_HFC1 */
+#define B2R2BLT_HFC1K7 (0xff000000)
+#define B2R2BLT_HFC1K7Shift (0x18)
+#define B2R2BLT_HFC1K6 (0xff0000)
+#define B2R2BLT_HFC1K6Shift (0x10)
+#define B2R2BLT_HFC1K5 (0xff00)
+#define B2R2BLT_HFC1K5Shift (0x8)
+#define B2R2BLT_HFC1K4 (0xff)
+#define B2R2BLT_HFC1K4Shift (0x0)
+#define B2R2BLT_HFC1Mask (0xffffffff)
+#define B2R2BLT_HFC1TestMask (0xffffffff)
+#define B2R2BLT_HFC1InitialValue (0x0)
+#define B2R2BLT_HFC1AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC1 (0xe04)
+
+/* - BLT_HFC2 */
+#define B2R2BLT_HFC2K13 (0xff000000)
+#define B2R2BLT_HFC2K13Shift (0x18)
+#define B2R2BLT_HFC2K12 (0xff0000)
+#define B2R2BLT_HFC2K12Shift (0x10)
+#define B2R2BLT_HFC2K11 (0xff00)
+#define B2R2BLT_HFC2K11Shift (0x8)
+#define B2R2BLT_HFC2K10 (0xff)
+#define B2R2BLT_HFC2K10Shift (0x0)
+#define B2R2BLT_HFC2Mask (0xffffffff)
+#define B2R2BLT_HFC2TestMask (0xffffffff)
+#define B2R2BLT_HFC2InitialValue (0x0)
+#define B2R2BLT_HFC2AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC2 (0xe08)
+
+/* - BLT_HFC3 */
+#define B2R2BLT_HFC3K17 (0xff000000)
+#define B2R2BLT_HFC3K17Shift (0x18)
+#define B2R2BLT_HFC3K16 (0xff0000)
+#define B2R2BLT_HFC3K16Shift (0x10)
+#define B2R2BLT_HFC3K15 (0xff00)
+#define B2R2BLT_HFC3K15Shift (0x8)
+#define B2R2BLT_HFC3K14 (0xff)
+#define B2R2BLT_HFC3K14Shift (0x0)
+#define B2R2BLT_HFC3Mask (0xffffffff)
+#define B2R2BLT_HFC3TestMask (0xffffffff)
+#define B2R2BLT_HFC3InitialValue (0x0)
+#define B2R2BLT_HFC3AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC3 (0xe0c)
+
+/* - BLT_HFC4 */
+#define B2R2BLT_HFC4K23 (0xff000000)
+#define B2R2BLT_HFC4K23Shift (0x18)
+#define B2R2BLT_HFC4K22 (0xff0000)
+#define B2R2BLT_HFC4K22Shift (0x10)
+#define B2R2BLT_HFC4K21 (0xff00)
+#define B2R2BLT_HFC4K21Shift (0x8)
+#define B2R2BLT_HFC4K20 (0xff)
+#define B2R2BLT_HFC4K20Shift (0x0)
+#define B2R2BLT_HFC4Mask (0xffffffff)
+#define B2R2BLT_HFC4TestMask (0xffffffff)
+#define B2R2BLT_HFC4InitialValue (0x0)
+#define B2R2BLT_HFC4AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC4 (0xe10)
+
+/* - BLT_HFC5 */
+#define B2R2BLT_HFC5K27 (0xff000000)
+#define B2R2BLT_HFC5K27Shift (0x18)
+#define B2R2BLT_HFC5K26 (0xff0000)
+#define B2R2BLT_HFC5K26Shift (0x10)
+#define B2R2BLT_HFC5K25 (0xff00)
+#define B2R2BLT_HFC5K25Shift (0x8)
+#define B2R2BLT_HFC5K24 (0xff)
+#define B2R2BLT_HFC5K24Shift (0x0)
+#define B2R2BLT_HFC5Mask (0xffffffff)
+#define B2R2BLT_HFC5TestMask (0xffffffff)
+#define B2R2BLT_HFC5InitialValue (0x0)
+#define B2R2BLT_HFC5AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC5 (0xe14)
+
+/* - BLT_HFC6 */
+#define B2R2BLT_HFC6K33 (0xff000000)
+#define B2R2BLT_HFC6K33Shift (0x18)
+#define B2R2BLT_HFC6K32 (0xff0000)
+#define B2R2BLT_HFC6K32Shift (0x10)
+#define B2R2BLT_HFC6K31 (0xff00)
+#define B2R2BLT_HFC6K31Shift (0x8)
+#define B2R2BLT_HFC6K30 (0xff)
+#define B2R2BLT_HFC6K30Shift (0x0)
+#define B2R2BLT_HFC6Mask (0xffffffff)
+#define B2R2BLT_HFC6TestMask (0xffffffff)
+#define B2R2BLT_HFC6InitialValue (0x0)
+#define B2R2BLT_HFC6AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC6 (0xe18)
+
+/* - BLT_HFC7 */
+#define B2R2BLT_HFC7K37 (0xff000000)
+#define B2R2BLT_HFC7K37Shift (0x18)
+#define B2R2BLT_HFC7K36 (0xff0000)
+#define B2R2BLT_HFC7K36Shift (0x10)
+#define B2R2BLT_HFC7K35 (0xff00)
+#define B2R2BLT_HFC7K35Shift (0x8)
+#define B2R2BLT_HFC7K34 (0xff)
+#define B2R2BLT_HFC7K34Shift (0x0)
+#define B2R2BLT_HFC7Mask (0xffffffff)
+#define B2R2BLT_HFC7TestMask (0xffffffff)
+#define B2R2BLT_HFC7InitialValue (0x0)
+#define B2R2BLT_HFC7AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC7 (0xe1c)
+
+/* - BLT_HFC8 */
+#define B2R2BLT_HFC8K43 (0xff000000)
+#define B2R2BLT_HFC8K43Shift (0x18)
+#define B2R2BLT_HFC8K42 (0xff0000)
+#define B2R2BLT_HFC8K42Shift (0x10)
+#define B2R2BLT_HFC8K41 (0xff00)
+#define B2R2BLT_HFC8K41Shift (0x8)
+#define B2R2BLT_HFC8K40 (0xff)
+#define B2R2BLT_HFC8K40Shift (0x0)
+#define B2R2BLT_HFC8Mask (0xffffffff)
+#define B2R2BLT_HFC8TestMask (0xffffffff)
+#define B2R2BLT_HFC8InitialValue (0x0)
+#define B2R2BLT_HFC8AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC8 (0xe20)
+
+/* - BLT_HFC9 */
+#define B2R2BLT_HFC9K47 (0xff000000)
+#define B2R2BLT_HFC9K47Shift (0x18)
+#define B2R2BLT_HFC9K46 (0xff0000)
+#define B2R2BLT_HFC9K46Shift (0x10)
+#define B2R2BLT_HFC9K45 (0xff00)
+#define B2R2BLT_HFC9K45Shift (0x8)
+#define B2R2BLT_HFC9K44 (0xff)
+#define B2R2BLT_HFC9K44Shift (0x0)
+#define B2R2BLT_HFC9Mask (0xffffffff)
+#define B2R2BLT_HFC9TestMask (0xffffffff)
+#define B2R2BLT_HFC9InitialValue (0x0)
+#define B2R2BLT_HFC9AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC9 (0xe24)
+
+/* - BLT_HFC10 */
+#define B2R2BLT_HFC10K53 (0xff000000)
+#define B2R2BLT_HFC10K53Shift (0x18)
+#define B2R2BLT_HFC10K52 (0xff0000)
+#define B2R2BLT_HFC10K52Shift (0x10)
+#define B2R2BLT_HFC10K51 (0xff00)
+#define B2R2BLT_HFC10K51Shift (0x8)
+#define B2R2BLT_HFC10K50 (0xff)
+#define B2R2BLT_HFC10K50Shift (0x0)
+#define B2R2BLT_HFC10Mask (0xffffffff)
+#define B2R2BLT_HFC10TestMask (0xffffffff)
+#define B2R2BLT_HFC10InitialValue (0x0)
+#define B2R2BLT_HFC10AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC10 (0xe28)
+
+/* - BLT_HFC11 */
+#define B2R2BLT_HFC11K57 (0xff000000)
+#define B2R2BLT_HFC11K57Shift (0x18)
+#define B2R2BLT_HFC11K56 (0xff0000)
+#define B2R2BLT_HFC11K56Shift (0x10)
+#define B2R2BLT_HFC11K55 (0xff00)
+#define B2R2BLT_HFC11K55Shift (0x8)
+#define B2R2BLT_HFC11K54 (0xff)
+#define B2R2BLT_HFC11K54Shift (0x0)
+#define B2R2BLT_HFC11Mask (0xffffffff)
+#define B2R2BLT_HFC11TestMask (0xffffffff)
+#define B2R2BLT_HFC11InitialValue (0x0)
+#define B2R2BLT_HFC11AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC11 (0xe2c)
+
+/* - BLT_HFC12 */
+#define B2R2BLT_HFC12K63 (0xff000000)
+#define B2R2BLT_HFC12K63Shift (0x18)
+#define B2R2BLT_HFC12K62 (0xff0000)
+#define B2R2BLT_HFC12K62Shift (0x10)
+#define B2R2BLT_HFC12K61 (0xff00)
+#define B2R2BLT_HFC12K61Shift (0x8)
+#define B2R2BLT_HFC12K60 (0xff)
+#define B2R2BLT_HFC12K60Shift (0x0)
+#define B2R2BLT_HFC12Mask (0xffffffff)
+#define B2R2BLT_HFC12TestMask (0xffffffff)
+#define B2R2BLT_HFC12InitialValue (0x0)
+#define B2R2BLT_HFC12AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC12 (0xe30)
+
+/* - BLT_HFC13 */
+#define B2R2BLT_HFC13K67 (0xff000000)
+#define B2R2BLT_HFC13K67Shift (0x18)
+#define B2R2BLT_HFC13K66 (0xff0000)
+#define B2R2BLT_HFC13K66Shift (0x10)
+#define B2R2BLT_HFC13K65 (0xff00)
+#define B2R2BLT_HFC13K65Shift (0x8)
+#define B2R2BLT_HFC13K64 (0xff)
+#define B2R2BLT_HFC13K64Shift (0x0)
+#define B2R2BLT_HFC13Mask (0xffffffff)
+#define B2R2BLT_HFC13TestMask (0xffffffff)
+#define B2R2BLT_HFC13InitialValue (0x0)
+#define B2R2BLT_HFC13AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC13 (0xe34)
+
+/* - BLT_HFC14 */
+#define B2R2BLT_HFC14K73 (0xff000000)
+#define B2R2BLT_HFC14K73Shift (0x18)
+#define B2R2BLT_HFC14K72 (0xff0000)
+#define B2R2BLT_HFC14K72Shift (0x10)
+#define B2R2BLT_HFC14K71 (0xff00)
+#define B2R2BLT_HFC14K71Shift (0x8)
+#define B2R2BLT_HFC14K70 (0xff)
+#define B2R2BLT_HFC14K70Shift (0x0)
+#define B2R2BLT_HFC14Mask (0xffffffff)
+#define B2R2BLT_HFC14TestMask (0xffffffff)
+#define B2R2BLT_HFC14InitialValue (0x0)
+#define B2R2BLT_HFC14AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC14 (0xe38)
+
+/* - BLT_HFC15 */
+#define B2R2BLT_HFC15K77 (0xff000000)
+#define B2R2BLT_HFC15K77Shift (0x18)
+#define B2R2BLT_HFC15K76 (0xff0000)
+#define B2R2BLT_HFC15K76Shift (0x10)
+#define B2R2BLT_HFC15K75 (0xff00)
+#define B2R2BLT_HFC15K75Shift (0x8)
+#define B2R2BLT_HFC15K74 (0xff)
+#define B2R2BLT_HFC15K74Shift (0x0)
+#define B2R2BLT_HFC15Mask (0xffffffff)
+#define B2R2BLT_HFC15TestMask (0xffffffff)
+#define B2R2BLT_HFC15InitialValue (0x0)
+#define B2R2BLT_HFC15AccessType (INITIAL_TEST)
+#define B2R2BLT_HFC15 (0xe3c)
+
+/* - BLT_VFC0 */
+#define B2R2BLT_VFC0K3 (0xff000000)
+#define B2R2BLT_VFC0K3Shift (0x18)
+#define B2R2BLT_VFC0K2 (0xff0000)
+#define B2R2BLT_VFC0K2Shift (0x10)
+#define B2R2BLT_VFC0K1 (0xff00)
+#define B2R2BLT_VFC0K1Shift (0x8)
+#define B2R2BLT_VFC0K0 (0xff)
+#define B2R2BLT_VFC0K0Shift (0x0)
+#define B2R2BLT_VFC0Mask (0xffffffff)
+#define B2R2BLT_VFC0TestMask (0xffffffff)
+#define B2R2BLT_VFC0InitialValue (0x0)
+#define B2R2BLT_VFC0AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC0 (0xe90)
+
+/* - BLT_VFC1 */
+#define B2R2BLT_VFC1K12 (0xff000000)
+#define B2R2BLT_VFC1K12Shift (0x18)
+#define B2R2BLT_VFC1K11 (0xff0000)
+#define B2R2BLT_VFC1K11Shift (0x10)
+#define B2R2BLT_VFC1K10 (0xff00)
+#define B2R2BLT_VFC1K10Shift (0x8)
+#define B2R2BLT_VFC1K4 (0xff)
+#define B2R2BLT_VFC1K4Shift (0x0)
+#define B2R2BLT_VFC1Mask (0xffffffff)
+#define B2R2BLT_VFC1TestMask (0xffffffff)
+#define B2R2BLT_VFC1InitialValue (0x0)
+#define B2R2BLT_VFC1AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC1 (0xe94)
+
+/* - BLT_VFC2 */
+#define B2R2BLT_VFC2K21 (0xff000000)
+#define B2R2BLT_VFC2K21Shift (0x18)
+#define B2R2BLT_VFC2K20 (0xff0000)
+#define B2R2BLT_VFC2K20Shift (0x10)
+#define B2R2BLT_VFC2K14 (0xff00)
+#define B2R2BLT_VFC2K14Shift (0x8)
+#define B2R2BLT_VFC2K13 (0xff)
+#define B2R2BLT_VFC2K13Shift (0x0)
+#define B2R2BLT_VFC2Mask (0xffffffff)
+#define B2R2BLT_VFC2TestMask (0xffffffff)
+#define B2R2BLT_VFC2InitialValue (0x0)
+#define B2R2BLT_VFC2AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC2 (0xe98)
+
+/* - BLT_VFC3 */
+#define B2R2BLT_VFC3K30 (0xff000000)
+#define B2R2BLT_VFC3K30Shift (0x18)
+#define B2R2BLT_VFC3K24 (0xff0000)
+#define B2R2BLT_VFC3K24Shift (0x10)
+#define B2R2BLT_VFC3K23 (0xff00)
+#define B2R2BLT_VFC3K23Shift (0x8)
+#define B2R2BLT_VFC3K22 (0xff)
+#define B2R2BLT_VFC3K22Shift (0x0)
+#define B2R2BLT_VFC3Mask (0xffffffff)
+#define B2R2BLT_VFC3TestMask (0xffffffff)
+#define B2R2BLT_VFC3InitialValue (0x0)
+#define B2R2BLT_VFC3AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC3 (0xe9c)
+
+/* - BLT_VFC4 */
+#define B2R2BLT_VFC4K34 (0xff000000)
+#define B2R2BLT_VFC4K34Shift (0x18)
+#define B2R2BLT_VFC4K33 (0xff0000)
+#define B2R2BLT_VFC4K33Shift (0x10)
+#define B2R2BLT_VFC4K32 (0xff00)
+#define B2R2BLT_VFC4K32Shift (0x8)
+#define B2R2BLT_VFC4K31 (0xff)
+#define B2R2BLT_VFC4K31Shift (0x0)
+#define B2R2BLT_VFC4Mask (0xffffffff)
+#define B2R2BLT_VFC4TestMask (0xffffffff)
+#define B2R2BLT_VFC4InitialValue (0x0)
+#define B2R2BLT_VFC4AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC4 (0xea0)
+
+/* - BLT_VFC5 */
+#define B2R2BLT_VFC5K43 (0xff000000)
+#define B2R2BLT_VFC5K43Shift (0x18)
+#define B2R2BLT_VFC5K42 (0xff0000)
+#define B2R2BLT_VFC5K42Shift (0x10)
+#define B2R2BLT_VFC5K41 (0xff00)
+#define B2R2BLT_VFC5K41Shift (0x8)
+#define B2R2BLT_VFC5K40 (0xff)
+#define B2R2BLT_VFC5K40Shift (0x0)
+#define B2R2BLT_VFC5Mask (0xffffffff)
+#define B2R2BLT_VFC5TestMask (0xffffffff)
+#define B2R2BLT_VFC5InitialValue (0x0)
+#define B2R2BLT_VFC5AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC5 (0xea4)
+
+/* - BLT_VFC6 */
+#define B2R2BLT_VFC6K52 (0xff000000)
+#define B2R2BLT_VFC6K52Shift (0x18)
+#define B2R2BLT_VFC6K51 (0xff0000)
+#define B2R2BLT_VFC6K51Shift (0x10)
+#define B2R2BLT_VFC6K50 (0xff00)
+#define B2R2BLT_VFC6K50Shift (0x8)
+#define B2R2BLT_VFC6K44 (0xff)
+#define B2R2BLT_VFC6K44Shift (0x0)
+#define B2R2BLT_VFC6Mask (0xffffffff)
+#define B2R2BLT_VFC6TestMask (0xffffffff)
+#define B2R2BLT_VFC6InitialValue (0x0)
+#define B2R2BLT_VFC6AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC6 (0xea8)
+
+/* - BLT_VFC7 */
+#define B2R2BLT_VFC7K61 (0xff000000)
+#define B2R2BLT_VFC7K61Shift (0x18)
+#define B2R2BLT_VFC7K60 (0xff0000)
+#define B2R2BLT_VFC7K60Shift (0x10)
+#define B2R2BLT_VFC7K54 (0xff00)
+#define B2R2BLT_VFC7K54Shift (0x8)
+#define B2R2BLT_VFC7K53 (0xff)
+#define B2R2BLT_VFC7K53Shift (0x0)
+#define B2R2BLT_VFC7Mask (0xffffffff)
+#define B2R2BLT_VFC7TestMask (0xffffffff)
+#define B2R2BLT_VFC7InitialValue (0x0)
+#define B2R2BLT_VFC7AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC7 (0xeac)
+
+/* - BLT_VFC8 */
+#define B2R2BLT_VFC8K70 (0xff000000)
+#define B2R2BLT_VFC8K70Shift (0x18)
+#define B2R2BLT_VFC8K64 (0xff0000)
+#define B2R2BLT_VFC8K64Shift (0x10)
+#define B2R2BLT_VFC8K63 (0xff00)
+#define B2R2BLT_VFC8K63Shift (0x8)
+#define B2R2BLT_VFC8K62 (0xff)
+#define B2R2BLT_VFC8K62Shift (0x0)
+#define B2R2BLT_VFC8Mask (0xffffffff)
+#define B2R2BLT_VFC8TestMask (0xffffffff)
+#define B2R2BLT_VFC8InitialValue (0x0)
+#define B2R2BLT_VFC8AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC8 (0xeb0)
+
+/* - BLT_VFC9 */
+#define B2R2BLT_VFC9K74 (0xff000000)
+#define B2R2BLT_VFC9K74Shift (0x18)
+#define B2R2BLT_VFC9K73 (0xff0000)
+#define B2R2BLT_VFC9K73Shift (0x10)
+#define B2R2BLT_VFC9K72 (0xff00)
+#define B2R2BLT_VFC9K72Shift (0x8)
+#define B2R2BLT_VFC9K71 (0xff)
+#define B2R2BLT_VFC9K71Shift (0x0)
+#define B2R2BLT_VFC9Mask (0xffffffff)
+#define B2R2BLT_VFC9TestMask (0xffffffff)
+#define B2R2BLT_VFC9InitialValue (0x0)
+#define B2R2BLT_VFC9AccessType (INITIAL_TEST)
+#define B2R2BLT_VFC9 (0xeb4)
+
+/* Instance values */
+#define asicB2R2BLT_CTL (0x70130a00)
+#define asicB2R2BLT_ITS (0x70130a04)
+#define asicB2R2BLT_STA1 (0x70130a08)
+#define asicB2R2BLT_SSBA1 (0x70130a10)
+#define asicB2R2BLT_SSBA2 (0x70130a14)
+#define asicB2R2BLT_SSBA3 (0x70130a18)
+#define asicB2R2BLT_SSBA4 (0x70130a1c)
+#define asicB2R2BLT_SSBA5 (0x70130a20)
+#define asicB2R2BLT_SSBA6 (0x70130a24)
+#define asicB2R2BLT_SSBA7 (0x70130a28)
+#define asicB2R2BLT_SSBA8 (0x70130a2c)
+#define asicB2R2BLT_SSBA9 (0x70130aa0)
+#define asicB2R2BLT_SSBA10 (0x70130aa4)
+#define asicB2R2BLT_SSBA11 (0x70130aa8)
+#define asicB2R2BLT_SSBA12 (0x70130aac)
+#define asicB2R2BLT_SSBA13 (0x70130ab0)
+#define asicB2R2BLT_SSBA14 (0x70130ab4)
+#define asicB2R2BLT_SSBA15 (0x70130ab8)
+#define asicB2R2BLT_SSBA16 (0x70130abc)
+#define asicB2R2BLT_STBA1 (0x70130a30)
+#define asicB2R2BLT_STBA2 (0x70130a34)
+#define asicB2R2BLT_STBA3 (0x70130a38)
+#define asicB2R2BLT_STBA4 (0x70130a3c)
+#define asicB2R2BLT_CQ1_TRIG_IP (0x70130a40)
+#define asicB2R2BLT_CQ2_TRIG_IP (0x70130a50)
+#define asicB2R2BLT_CQ1_TRIG_CTL (0x70130a44)
+#define asicB2R2BLT_CQ2_TRIG_CTL (0x70130a54)
+#define asicB2R2BLT_CQ1_PACE_CTL (0x70130a48)
+#define asicB2R2BLT_CQ2_PACE_CTL (0x70130a58)
+#define asicB2R2BLT_CQ1_IP (0x70130a4c)
+#define asicB2R2BLT_CQ2_IP (0x70130a5c)
+#define asicB2R2BLT_AQ1_CTL (0x70130a60)
+#define asicB2R2BLT_AQ2_CTL (0x70130a70)
+#define asicB2R2BLT_AQ3_CTL (0x70130a80)
+#define asicB2R2BLT_AQ4_CTL (0x70130a90)
+#define asicB2R2BLT_AQ1_IP (0x70130a64)
+#define asicB2R2BLT_AQ2_IP (0x70130a74)
+#define asicB2R2BLT_AQ3_IP (0x70130a84)
+#define asicB2R2BLT_AQ4_IP (0x70130a94)
+#define asicB2R2BLT_AQ1_LNA (0x70130a68)
+#define asicB2R2BLT_AQ2_LNA (0x70130a78)
+#define asicB2R2BLT_AQ3_LNA (0x70130a88)
+#define asicB2R2BLT_AQ4_LNA (0x70130a98)
+#define asicB2R2BLT_AQ1_STA (0x70130a6c)
+#define asicB2R2BLT_AQ2_STA (0x70130a7c)
+#define asicB2R2BLT_AQ3_STA (0x70130a8c)
+#define asicB2R2BLT_AQ4_STA (0x70130a9c)
+#define asicB2R2BLT_SGA1 (0x70130ac0)
+#define asicB2R2BLT_SGA2 (0x70130ac4)
+#define asicB2R2BLT_ITM0 (0x70130ad0)
+#define asicB2R2BLT_ITM1 (0x70130ad4)
+#define asicB2R2BLT_ITM2 (0x70130ad8)
+#define asicB2R2BLT_ITM3 (0x70130adc)
+#define asicB2R2BLT_DFV1 (0x70130af4)
+#define asicB2R2BLT_DFV2 (0x70130af0)
+#define asicB2R2BLT_PRI (0x70130af8)
+#define asicB2R2BLT_SSBA17 (0x70130900)
+#define asicB2R2BLT_SSBA18 (0x70130904)
+#define asicB2R2BLT_SSBA19 (0x70130908)
+#define asicB2R2BLT_SSBA20 (0x7013090c)
+#define asicB2R2BLT_SSBA21 (0x70130910)
+#define asicB2R2BLT_SSBA22 (0x70130914)
+#define asicB2R2BLT_SSBA23 (0x70130918)
+#define asicB2R2BLT_SSBA24 (0x7013091c)
+#define asicB2R2BLT_STBA5 (0x70130940)
+#define asicB2R2BLT_STBA6 (0x70130944)
+#define asicB2R2BLT_STBA7 (0x70130948)
+#define asicB2R2BLT_STBA8 (0x7013094c)
+#define asicB2R2PLUGS1_OP2 (0x70130b04)
+#define asicB2R2PLUGS2_OP2 (0x70130b24)
+#define asicB2R2PLUGS3_OP2 (0x70130b44)
+#define asicB2R2PLUGS1_CHZ (0x70130b08)
+#define asicB2R2PLUGS2_CHZ (0x70130b28)
+#define asicB2R2PLUGS3_CHZ (0x70130b48)
+#define asicB2R2PLUGS1_MSZ (0x70130b0c)
+#define asicB2R2PLUGS2_MSZ (0x70130b2c)
+#define asicB2R2PLUGS3_MSZ (0x70130b4c)
+#define asicB2R2PLUGS1_PGZ (0x70130b10)
+#define asicB2R2PLUGS2_PGZ (0x70130b30)
+#define asicB2R2PLUGS3_PGZ (0x70130b50)
+#define asicB2R2PLUGT_OP2 (0x70130b84)
+#define asicB2R2PLUGT_CHZ (0x70130b88)
+#define asicB2R2PLUGT_MSZ (0x70130b8c)
+#define asicB2R2PLUGT_PGZ (0x70130b90)
+#define asicB2R2BLT_NIP (0x70130c00)
+#define asicB2R2BLT_CIC (0x70130c04)
+#define asicB2R2BLT_INS (0x70130c08)
+#define asicB2R2BLT_ACK (0x70130c0c)
+#define asicB2R2BLT_TBA (0x70130c10)
+#define asicB2R2BLT_TTY (0x70130c14)
+#define asicB2R2BLT_TXY (0x70130c18)
+#define asicB2R2BLT_TSZ (0x70130c1c)
+#define asicB2R2BLT_S1CF (0x70130c20)
+#define asicB2R2BLT_S2CF (0x70130c24)
+#define asicB2R2BLT_S1BA (0x70130c28)
+#define asicB2R2BLT_S1TY (0x70130c2c)
+#define asicB2R2BLT_S1XY (0x70130c30)
+#define asicB2R2BLT_S2BA (0x70130c38)
+#define asicB2R2BLT_S2TY (0x70130c3c)
+#define asicB2R2BLT_S2XY (0x70130c40)
+#define asicB2R2BLT_S2SZ (0x70130c44)
+#define asicB2R2BLT_S2SZ (0x70130c44)
+#define asicB2R2BLT_S3BA (0x70130c48)
+#define asicB2R2BLT_S3TY (0x70130c4c)
+#define asicB2R2BLT_S3XY (0x70130c50)
+#define asicB2R2BLT_S3SZ (0x70130c54)
+#define asicB2R2BLT_CWO (0x70130c58)
+#define asicB2R2BLT_CWS (0x70130c5c)
+#define asicB2R2BLT_CCO (0x70130c60)
+#define asicB2R2BLT_CML (0x70130c64)
+#define asicB2R2BLT_FCTL (0x70130c68)
+#define asicB2R2BLT_PMK (0x70130c6c)
+#define asicB2R2BLT_RSF (0x70130c70)
+#define asicB2R2BLT_RZI (0x70130c74)
+#define asicB2R2BLT_HFP (0x70130c78)
+#define asicB2R2BLT_VFP (0x70130c7c)
+#define asicB2R2BLT_Y_RSF (0x70130c80)
+#define asicB2R2BLT_Y_RZI (0x70130c84)
+#define asicB2R2BLT_Y_HFP (0x70130c88)
+#define asicB2R2BLT_Y_VFP (0x70130c8c)
+#define asicB2R2BLT_KEY1 (0x70130ca0)
+#define asicB2R2BLT_KEY2 (0x70130ca4)
+#define asicB2R2BLT_SAR (0x70130cb0)
+#define asicB2R2BLT_USR (0x70130cb4)
+#define asicB2R2BLT_IVMX0 (0x70130cc0)
+#define asicB2R2BLT_IVMX1 (0x70130cc4)
+#define asicB2R2BLT_IVMX2 (0x70130cc8)
+#define asicB2R2BLT_IVMX3 (0x70130ccc)
+#define asicB2R2BLT_OVMX0 (0x70130cd0)
+#define asicB2R2BLT_OVMX1 (0x70130cd4)
+#define asicB2R2BLT_OVMX2 (0x70130cd8)
+#define asicB2R2BLT_OVMX3 (0x70130cdc)
+#define asicB2R2BLT_VC1R (0x70130ce8)
+#define asicB2R2BLT_HFC0 (0x70130e00)
+#define asicB2R2BLT_HFC1 (0x70130e04)
+#define asicB2R2BLT_HFC2 (0x70130e08)
+#define asicB2R2BLT_HFC3 (0x70130e0c)
+#define asicB2R2BLT_HFC4 (0x70130e10)
+#define asicB2R2BLT_HFC5 (0x70130e14)
+#define asicB2R2BLT_HFC6 (0x70130e18)
+#define asicB2R2BLT_HFC7 (0x70130e1c)
+#define asicB2R2BLT_HFC8 (0x70130e20)
+#define asicB2R2BLT_HFC9 (0x70130e24)
+#define asicB2R2BLT_HFC10 (0x70130e28)
+#define asicB2R2BLT_HFC11 (0x70130e2c)
+#define asicB2R2BLT_HFC12 (0x70130e30)
+#define asicB2R2BLT_HFC13 (0x70130e34)
+#define asicB2R2BLT_HFC14 (0x70130e38)
+#define asicB2R2BLT_HFC15 (0x70130e3c)
+#define asicB2R2BLT_VFC0 (0x70130e90)
+#define asicB2R2BLT_VFC1 (0x70130e94)
+#define asicB2R2BLT_VFC2 (0x70130e98)
+#define asicB2R2BLT_VFC3 (0x70130e9c)
+#define asicB2R2BLT_VFC4 (0x70130ea0)
+#define asicB2R2BLT_VFC5 (0x70130ea4)
+#define asicB2R2BLT_VFC6 (0x70130ea8)
+#define asicB2R2BLT_VFC7 (0x70130eac)
+#define asicB2R2BLT_VFC8 (0x70130eb0)
+#define asicB2R2BLT_VFC9 (0x70130eb4)
+#define asicB2R2BLT_Y_HFC0 (0x70130d00)
+#define asicB2R2BLT_Y_HFC1 (0x70130d04)
+#define asicB2R2BLT_Y_HFC2 (0x70130d08)
+#define asicB2R2BLT_Y_HFC3 (0x70130d0c)
+#define asicB2R2BLT_Y_HFC4 (0x70130d10)
+#define asicB2R2BLT_Y_HFC5 (0x70130d14)
+#define asicB2R2BLT_Y_HFC6 (0x70130d18)
+#define asicB2R2BLT_Y_HFC7 (0x70130d1c)
+#define asicB2R2BLT_Y_HFC8 (0x70130d20)
+#define asicB2R2BLT_Y_HFC9 (0x70130d24)
+#define asicB2R2BLT_Y_HFC10 (0x70130d28)
+#define asicB2R2BLT_Y_HFC11 (0x70130d2c)
+#define asicB2R2BLT_Y_HFC12 (0x70130d30)
+#define asicB2R2BLT_Y_HFC13 (0x70130d34)
+#define asicB2R2BLT_Y_HFC14 (0x70130d38)
+#define asicB2R2BLT_Y_HFC15 (0x70130d3c)
+#define asicB2R2BLT_Y_VFC0 (0x70130d90)
+#define asicB2R2BLT_Y_VFC1 (0x70130d94)
+#define asicB2R2BLT_Y_VFC2 (0x70130d98)
+#define asicB2R2BLT_Y_VFC3 (0x70130d9c)
+#define asicB2R2BLT_Y_VFC4 (0x70130da0)
+#define asicB2R2BLT_Y_VFC5 (0x70130da4)
+#define asicB2R2BLT_Y_VFC6 (0x70130da8)
+#define asicB2R2BLT_Y_VFC7 (0x70130dac)
+#define asicB2R2BLT_Y_VFC8 (0x70130db0)
+#define asicB2R2BLT_Y_VFC9 (0x70130db4)
+
+
+//------------------------------------------------------------------------
+// Static Register bits defines
+//------------------------------------------------------------------------
+/* - BLT_AQ_CTL */
+#define B2R2_AQ_Enab (0x80000000)
+#define B2R2_AQ_PRIOR_0 (0x0)
+#define B2R2_AQ_PRIOR_1 (0x1)
+#define B2R2_AQ_PRIOR_2 (0x2)
+#define B2R2_AQ_PRIOR_3 (0x3)
+#define B2R2_AQ_NODE_REPEAT_INT (0x100000)
+#define B2R2_AQ_STOP_INT (0x200000)
+#define B2R2_AQ_LNA_REACH_INT (0x400000)
+#define B2R2_AQ_COMPLETED_INT (0x800000)
+
+/* - BLT_CIC */
+#define B2R2_CICGroup18 (0x40000)
+#define B2R2_CICGroup17 (0x20000)
+#define B2R2_OUTPUT_VMx (0x10000)
+#define B2R2_INPUT_VMx (0x00008000)
+#define B2R2_CICGroup14 (0x00004000)
+#define B2R2_CICGroup13 (0x00002000)
+#define B2R2_COLOR_KEY (0x00001000)
+#define B2R2_FLICKER_FILTER (0x00000800)
+#define B2R2_LUMA_FILTER (0x00000400)
+#define B2R2_RGB_CHROMA (0x00000200)
+#define B2R2_FILTER_CTL_MASK (0x00000100)
+#define B2R2_CLUT (0x00000080)
+#define B2R2_CLIP_WIN (0x00000040)
+#define B2R2_SRC3 (0x00000020)
+#define B2R2_SRC2 (0x00000010)
+#define B2R2_SRC1 (0x00000008)
+#define B2R2_COLOR_FILL (0x00000004)
+
+/* - BLT_INS */
+#define B2R2_SRC1_FETCH_MEM (0x00000001)
+#define B2R2_SRC1_COLOR_FILL (0x00000003)
+#define B2R2_SRC1_DIRECT_COPY (0x00000004)
+#define B2R2_SRC1_DIRECT_FILL (0x00000007)
+#define B2R2_SRC2_FETCH_MEM (0x00000008)
+#define B2R2_SRC2_COLOR_FILL (0x00000018)
+#define B2R2_SRC3_FETCH_MEM (0x00000020)
+
+/* - BLT_ACK */
+#define B2R2_BYPASS_SRC1 (0x00000000)
+#define B2R2_LOGICAL_OPER (0x00000001)
+#define B2R2_BLEND_NOT_PREMULT (0x00000002)
+#define B2R2_BLEND_PREMULT (0x00000003)
+#define B2R2_LOGICAL_FIRST_PASS (0x00000004)
+#define B2R2_CLIPMASK_BLEND (0x00000005)
+#define B2R2_BYPASS_SRC2_SRC3 (0x00000007)
+#define B2R2_LOGICAL_2ND_PASS (0x00000008)
+
+/*BLT_TTY */
+#define B2R2_ALPHA_RANGE_SHIFT (0x15)
+/*BLT_XY */
+#define B2R2_Y_SHIFT (0x10)
+
+/*BLT_SCF*/
+#define COLOR_ALPHA_SHIFT (0x18)
+#define RED_COLOR_SHIFT (0x10)
+#define GREEN_COLOR_SHIFT (0x08)
+#define BLUE_COLOR_SHIFT (0x00)
+
+/* SRC REG*/
+#define B2R2_STYCOLOR_FORMShift (0x10)
+#define B2R2_SSZWIN_HEIGHTShift (0x10)
+
+/* - BLT_CCO */
+#define B2R2_COLOR_CORREC (0x00010000)
+#define B2R2_COLOR_REDUC (0x00020000)
+#define B2R2_CLUT_100_ERRDIF (0x00080000)
+#define B2R2_CLUT_75_ERRDIF (0x00100000)
+#define B2R2_CLUT_50_ERRDIF (0x00180000)
+#define B2R2_CLUT_25_ERRDIF (0x00200000)
+#define B2R2_CLUT_ADAPT (0x00400000)
+
+
+/** Sources involved */
+
+typedef enum
+{
+ SOURCE = 0,
+ SOURCE1 = 1,
+ SOURCE2 = 2,
+ SOURCE3 = 3,
+ SOURCE12 = 4, //Both Source1 & Source2 will be used
+ SOURCE13 = 5, //Both Source1 & Source3 will be used
+ SOURCE23 = 6, //Both Source2 & Source3 will be used
+ SOURCE123 = 7 //All sources (Source1, Source2 & Source3)
+
+}b2r2_source_involved;
+
+
+typedef enum
+{
+ BYPASS_SRC1 = 0,
+ LOGICAL_OP = 1,
+ BLENDING_FG_NOT_PREMULT = 2,
+ BLENDING_FG_PREMULT = 3,
+ CLIPMASK_LOG_MODE_1ST_PASS = 4,
+ CLIPMASK_BLENDING_MODE = 5,
+ BYPASS_SRC2_SRC3 = 7
+
+}b2r2_alu_op_mode;
+
+
+
+typedef struct
+{
+ unsigned char COLORFILL_EN;
+ b2r2_source_involved COLOR_FILL_SOURCE;
+ b2r2_alu_op_mode ALU_OP_MODE;
+
+}b2r2_seting_flags;
+
+
+
+typedef struct
+{
+ unsigned char ALPHA_VAL;
+ unsigned char SWAP_FG_BG;
+ unsigned char PREMULTIPLIER;
+ unsigned char ALPHA_RANGE;
+
+}b2r2_blending_para;
+
+
+typedef enum
+{
+ INSIDE_CLIP = 0,
+ OUTSIDE_CLIP = 1
+
+}b2r2_clip_mode;
+
+
+typedef struct
+{
+ unsigned short B2R2_X_CORD;
+ unsigned short B2R2_Y_CORD;
+
+}b2r2_win_pos;
+
+
+typedef struct
+{
+ b2r2_clip_mode CLIP_MODE;
+ b2r2_win_pos CLIP_WIN_START_CORD;//Start coordinate of clipped area
+ b2r2_win_pos CLIP_WIN_END_CORD; // End coordinate of clipped area
+
+}b2r2_clip_para;
+
+
+typedef struct
+{
+ unsigned int B2R2_KEY1;
+ unsigned int B2R2_KEY2;
+
+}b2r2_color_key_val;
+
+
+typedef struct
+{
+ b2r2_color_key_val COLOR_KEYS_VAL;
+ unsigned char ACK_CKEY;
+ unsigned char CKEY_SEL;
+
+}b2r2_colorkey_para;
+
+
+typedef struct
+{
+ unsigned int S1_SSBA :5; //Possible values 1 to 4 or 9 to 12 When CQ used. Odd number for CQ1 & Even number for CQ2
+ unsigned int RESV1 :3;
+ unsigned int S2_SSBA :5; //Possible values 1 to 8 When When CQ used. Odd number for CQ1 & Even number for CQ2
+ unsigned int RESV2 :3;
+ unsigned int S3_SSBA :5; //Possible values 9 to 16 When When CQ used. Odd number for CQ1 & Even number for CQ2
+ unsigned int RESV3 :3;
+ unsigned int T_STBA :4;//Possible values 1 to 4.
+ unsigned int A_SGA :4;//Possible values 1 to 4.
+
+}b2r2_sar;
+
+typedef struct
+{
+ unsigned int LUMA_COEFF :3;
+ unsigned int LUMA_MAP :1; //This flag must be set to apply VC1 range functionality on Luma part
+ unsigned int CHROMA_COEFF :3;
+ unsigned int CHROMA_MAP :1; //This flag must be set to apply VC1 range functionality on Chroma part
+ unsigned int RESV :24;
+
+}b2r2_vc1_range;
+
+
+/** INS flag configuration */
+
+typedef struct
+{
+ unsigned long long CLIPPING_EN :1 ; // To utilize clip feature set this bit
+ unsigned long long CLUT_EN :1 ; // To utilize CLUT feature set this bit
+ unsigned long long COLORKEY_EN :1 ;
+ //unsigned double PLANEMASK_EN :1 ;
+ unsigned long long RESIZE_EN :1 ;
+ unsigned long long SAR_EN :1 ; // To utilize SAR feature set this bit
+ unsigned long long VM_EN :1 ;
+ unsigned long long VC1_EN :1 ;
+ unsigned long long DITHER_EN :1 ;
+ unsigned long long SRC1_RGB_EXP :1 ;
+ unsigned long long SRC2_RGB_EXP :1 ;
+ unsigned long long SRC1_A1_SUBST_EN :1 ;
+ unsigned long long SRC2_A1_SUBST_EN :1 ;
+ unsigned long long CHROMA_LEFT_EN :1 ;
+ unsigned long long SRC1_SUBBYTE :1 ;
+ unsigned long long SRC2_SUBBYTE :1 ;
+ unsigned long long TARG_SUBBYTE :1 ;
+ unsigned long long SRC1_ALPHA_RANGE :1 ;
+ unsigned long long SRC2_ALPHA_RANGE :1 ;
+ unsigned long long TARG_ALPHA_RANGE :1 ;
+ unsigned long long SRC1_BIGENDIAN :1 ;
+ unsigned long long SRC2_BIGENDIAN :1 ;
+ unsigned long long TARG_BIGENDIAN :1 ;
+ unsigned long long SRC1_HSO :1 ;
+ unsigned long long SRC2_HSO :1 ;
+ unsigned long long SRC3_HSO :1 ;
+ unsigned long long TARG_HSO :1 ;
+ unsigned long long SRC1_VSO :1 ;
+ unsigned long long SRC2_VSO :1 ;
+ unsigned long long SRC3_VSO :1 ;
+ unsigned long long TARG_VSO :1 ;
+ unsigned long long YCBCR420MB_INPUT :1 ; // Set this bit when input image is in 420 format
+ unsigned long long YCBCR422MB_INPUT :1 ; // Set this bit when input image is in 422 format
+
+ b2r2_seting_flags SETING_FLAGS;
+ b2r2_blending_para BLEND_PARA;
+ b2r2_clip_para CLIP_PARA;
+
+ unsigned int PMK_VAL;
+ //t_uint32 FILT_CNTL_EN;
+
+ b2r2_colorkey_para COLORKEY_PARA;
+ b2r2_sar SAR_CONFIG;
+ b2r2_vc1_range VC1_RANGE;
+
+
+}b2r2_functionality_ins;
+
+
+
+
+const unsigned int h_filt_coef[] = {
+0x00000000, 0x00000040, 0x08FD03FF, 0xFE04F93E,
+0x13F806FD, 0xFC07F43B, 0x1FF508FB, 0xFB09F134,
+0x2BF209FB, 0xFB09F12A, 0x35F209FB, 0xFB08F41E, //Increment less than 1024
+0x3CF507FC, 0xFD06F712, 0x3FFA04FE, 0xFF03FC07,
+
+0x05FC0400, 0x04FC0539, 0x0CF906FC, 0x0200FE39,
+0x17F608FB, 0x0002F935, 0x20F408FC, 0xFF05F430, //Increment bigger than 1024
+0x29F407FD, 0xFD07F328, 0x31F505FF, 0xFC08F31F,
+0x38F90200, 0xFB08F614, 0x3AFF0002, 0xFC06F80B,
+
+0x09F906FC, 0x06F90934, 0x10F707FD, 0x05FC0232,
+0x17F607FE, 0x04FFFC2F, 0x20F506FF, 0x0201F92A, //Resize 1.3 to 1.4
+0x27F60400, 0x0004F625, 0x2DF90102, 0xFF06F51D,
+0x31FDFF04, 0xFE07F515, 0x3502FC05, 0xFD07F70D,
+
+0x0BF806FE, 0x06F80B30, 0x12F706FF, 0x06FA052D,
+0x18F60400, 0x06FC002C, 0x1FF70201, 0x04FFFD27,
+0x24F90003, 0x0300F924, 0x29FDFF04, 0x0102F71D, //Resize 1.4 to 1.5
+0x2D00FC06, 0x0004F617, 0x3005FA06, 0xFF06F70F,
+
+ 0x13fbfd05, 0xfdfb1325, 0x17fdfc05, 0xfff90f24,
+ 0x1bfffa04, 0x00f90b24, 0x1f01f903, 0x01f80823,
+ 0x2204f902, 0x02f90420, 0x2508f801, 0x03f9011d,
+ 0x250cf900, 0x04fafe1a, 0x2610f9ff, 0x05fcfc15,
+
+ 0x1306fdfc, 0xfd061318, 0x1508fefc, 0xfc041217,
+ 0x160afefb, 0xfc031018, 0x180b00fb, 0xfb010f17,
+ 0x190d00fb, 0xfb000d17, 0x190f01fb, 0xfb000b16,
+ 0x191103fc, 0xfbfe0915, 0x1a1204fc, 0xfcfe0812,
+
+ 0x0f0902fe, 0x02090f0e, 0x0f0902ff, 0x01080e10,
+ 0x100a03ff, 0x00070d10, 0x100b0400, 0x00060c0f,
+ 0x100c0500, 0x00050c0e, 0x110c0600, 0x00040b0e,
+ 0x110d0700, 0xff030a0f, 0x110e0801, 0xff02090e,
+
+ 0x0c090400, 0x04090c0e, 0x0c090501, 0x04080c0d,
+ 0x0c0a0501, 0x03080b0e, 0x0d0a0602, 0x03070b0c, //Down scale between 5 and 4
+ 0x0d0a0702, 0x02070a0d, 0x0d0b0703, 0x02060a0c,
+ 0x0d0b0803, 0x01050a0d, 0x0d0c0804, 0x0105090c,
+
+ 0x0b090603, 0x06090b09, 0x0b090603, 0x05080a0c,
+ 0x0b090603, 0x05080a0c, 0x0b090704, 0x04080a0b, // Downscale bigger than 5
+ 0x0b0a0704, 0x04070a0b, 0x0b0a0804, 0x0407090b,
+ 0x0b0a0805, 0x0306090c, 0x0b0a0805, 0x0306090c
+
+
+};
+
+
+const unsigned int v_filt_coef[] = {
+
+ 0x00400000, 0x3c09fd00, 0x13f904fa, 0xf506f539,
+ 0x08f3311f, 0xf3282af3, 0x1d34f308, 0x3bf507f5,
+ 0xfa05f912, 0x03fd073f,
+
+ 0x053e05fc, 0x3b0ef8fc, 0x18f500ff, 0xf402f938,
+ 0x05f53121, 0xf4272af4, 0x1e30f607, 0x35f908f4,
+ 0xff07f615, 0x06f90b37,
+
+ 0x0a3c0af8, 0x3b12f6f8,
+ 0x1bf4fb02, 0xf4fffd35, 0x01f83023, 0xf62729f6,
+ 0x1e2ef904, 0x31fd06f5, 0x0206f616, 0x07f80d32,
+
+ 0x0e380ef6, 0x3815f5f6, 0x1df5f806, 0xf6fb0033,
+ 0xfefc2d23, 0xf92628f9, 0x1e2cfc00, 0x2e0003f7,
+ 0x0504f618, 0x05f7112e,
+
+ 0x132413fb, 0x2317fdfb,
+ 0x1afffa0f, 0x01f90b23, 0xf907221d, 0x041f2004,
+ 0x1c2207f9, 0x240bfa01, 0x0ffbff17, 0xfcfd1424,
+
+ 0x10161005, 0x16110605, 0x1308040f, 0x09020e15,
+ 0x010c1614, 0x0b15150b, 0x13160d00, 0x170f000a,
+ 0x11ff0813, 0xfe071218,
+
+ 0x0f100f09, 0x120f0909,
+ 0x100a080e, 0x0b070e11, 0x060d1111, 0x0c12110c,
+ 0x11120d05, 0x120e040c, 0x0f040b11, 0x030a1113,
+
+ 0x0e100e0a, 0x0f0e0b0a, 0x0f0b0a0e, 0x0c090d10,
+ 0x080d100f, 0x0d0f0f0d, 0x10100d08, 0x100e070c,
+ 0x0f070c0f, 0x060b1010,
+
+ 0x0e0e0e0b, 0x0f0e0b0b,
+ 0x0e0c0b0d, 0x0c0a0d0f, 0x0a0d0f0e, 0x0d0e0f0d,
+ 0x0f0f0d09, 0x0f0e090c, 0x0e090c0e, 0x080c0f0f
+};
+
+
+const unsigned int h_luma_filt_coef[] = {
+0x00000000, 0x00000040, 0x08FD03FF, 0xFE04F93E,
+0x13F806FD, 0xFC07F43B, 0x1FF508FB, 0xFB09F134,
+0x2BF209FB, 0xFB09F12A, 0x35F209FB, 0xFB08F41E, //Increment less than 1024
+0x3CF507FC, 0xFD06F712, 0x3FFA04FE, 0xFF03FC07,
+
+0x05FC0400, 0x04FC0539, 0x0CF906FC, 0x0200FE39,
+0x17F608FB, 0x0002F935, 0x20F408FC, 0xFF05F430, //Increment bigger than 1024
+0x29F407FD, 0xFD07F328, 0x31F505FF, 0xFC08F31F,
+0x38F90200, 0xFB08F614, 0x3AFF0002, 0xFC06F80B,
+
+0x09F906FC, 0x06F90934, 0x10F707FD, 0x05FC0232,
+0x17F607FE, 0x04FFFC2F, 0x20F506FF, 0x0201F92A, //Resize 1.4 to 1.3
+0x27F60400, 0x0004F625, 0x2DF90102, 0xFF06F51D,
+0x31FDFF04, 0xFE07F515, 0x3502FC05, 0xFD07F70D,
+
+0x0BF806FE, 0x06F80B30, 0x12F706FF, 0x06FA052D,
+0x18F60400, 0x06FC002C, 0x1FF70201, 0x04FFFD27,
+0x24F90003, 0x0300F924, 0x29FDFF04, 0x0102F71D, //Resize 1.4 to 1.5
+0x2D00FC06, 0x0004F617, 0x3005FA06, 0xFF06F70F,
+
+ 0x13fbfd05, 0xfdfb1325, 0x17fdfc05, 0xfff90f24,
+ 0x1bfffa04, 0x00f90b24, 0x1f01f903, 0x01f80823,
+ 0x2204f902, 0x02f90420, 0x2508f801, 0x03f9011d,
+ 0x250cf900, 0x04fafe1a, 0x2610f9ff, 0x05fcfc15,
+
+ 0x1306fdfc, 0xfd061318, 0x1508fefc, 0xfc041217,
+ 0x160afefb, 0xfc031018, 0x180b00fb, 0xfb010f17,
+ 0x190d00fb, 0xfb000d17, 0x190f01fb, 0xfb000b16,
+ 0x191103fc, 0xfbfe0915, 0x1a1204fc, 0xfcfe0812,
+
+ 0x0f0902fe, 0x02090f0e, 0x0f0902ff, 0x01080e10,
+ 0x100a03ff, 0x00070d10, 0x100b0400, 0x00060c0f,
+ 0x100c0500, 0x00050c0e, 0x110c0600, 0x00040b0e,
+ 0x110d0700, 0xff030a0f, 0x110e0801, 0xff02090e,
+
+ 0x0c090400, 0x04090c0e, 0x0c090501, 0x04080c0d,
+ 0x0c0a0501, 0x03080b0e, 0x0d0a0602, 0x03070b0c, //Downscale between 5 and 4
+ 0x0d0a0702, 0x02070a0d, 0x0d0b0703, 0x02060a0c,
+ 0x0d0b0803, 0x01050a0d, 0x0d0c0804, 0x0105090c,
+
+ 0x0b090603, 0x06090b09, 0x0b090603, 0x05080a0c,
+ 0x0b090603, 0x05080a0c, 0x0b090704, 0x04080a0b, // Downscale bigger than 5
+ 0x0b0a0704, 0x04070a0b, 0x0b0a0804, 0x0407090b,
+ 0x0b0a0805, 0x0306090c, 0x0b0a0805, 0x0306090c
+};
+
+
+const unsigned int v_luma_filt_coef[] = {
+
+ 0x00400000, 0x3c09fd00, 0x13f904fa, 0xf506f539,
+ 0x08f3311f, 0xf3282af3, 0x1d34f308, 0x3bf507f5,
+ 0xfa05f912, 0x03fd073f,
+
+ 0x053e05fc, 0x3b0ef8fc, 0x18f500ff, 0xf402f938,
+ 0x05f53121, 0xf4272af4, 0x1e30f607, 0x35f908f4,
+ 0xff07f615, 0x06f90b37,
+
+ 0x0a3c0af8, 0x3b12f6f8,
+ 0x1bf4fb02, 0xf4fffd35, 0x01f83023, 0xf62729f6,
+ 0x1e2ef904, 0x31fd06f5, 0x0206f616, 0x07f80d32,
+
+ 0x0e380ef6, 0x3815f5f6, 0x1df5f806, 0xf6fb0033,
+ 0xfefc2d23, 0xf92628f9, 0x1e2cfc00, 0x2e0003f7,
+ 0x0504f618, 0x05f7112e,
+
+ 0x132413fb, 0x2317fdfb,
+ 0x1afffa0f, 0x01f90b23, 0xf907221d, 0x041f2004,
+ 0x1c2207f9, 0x240bfa01, 0x0ffbff17, 0xfcfd1424,
+
+ 0x10161005, 0x16110605, 0x1308040f, 0x09020e15,
+ 0x010c1614, 0x0b15150b, 0x13160d00, 0x170f000a,
+ 0x11ff0813, 0xfe071218,
+
+ 0x0f100f09, 0x120f0909,
+ 0x100a080e, 0x0b070e11, 0x060d1111, 0x0c12110c,
+ 0x11120d05, 0x120e040c, 0x0f040b11, 0x030a1113,
+
+ 0x0e100e0a, 0x0f0e0b0a, 0x0f0b0a0e, 0x0c090d10,
+ 0x080d100f, 0x0d0f0f0d, 0x10100d08, 0x100e070c,
+ 0x0f070c0f, 0x060b1010,
+
+ 0x0e0e0e0b, 0x0f0e0b0b,
+ 0x0e0c0b0d, 0x0c0a0d0f, 0x0a0d0f0e, 0x0d0e0f0d,
+ 0x0f0f0d09, 0x0f0e090c, 0x0e090c0e, 0x080c0f0f
+};
+
+
+typedef struct
+{
+ unsigned short HSRC_INC ;
+ unsigned short VSRC_INC ;
+
+}b2r2_rsf;
+
+
+typedef struct
+{
+ unsigned int B2R2_HFP;
+ unsigned int B2R2_VFP;
+
+}b2r2_filter_coeff;
+
+
+typedef enum
+{
+ CHROMA_FILTER_CNTL = 0, //Use this enum to get setting for chroma filter
+ RESIZE_FILTER_CNTL = 0, //Use this enum to get setting for resizing filter when image is in RGB format
+ LUMA_FILTER_CNTL = 1, //Use this enum to get setting for luma filter
+
+}b2r2_filter_control;
+
+
+typedef enum
+{
+ HORIZONTAL_FILTER = 0,
+ VERTICAL_FILTER = 1,
+
+}b2r2_filter;
+
+
+typedef struct
+{
+ unsigned short B2R2_WIN_WIDTH;
+ unsigned short B2R2_WIN_HEIGHT;
+
+}b2r2_win_size;
+
+
+typedef struct
+{
+
+ unsigned int h_phy;
+ unsigned int v_phy;
+ unsigned int h_luma_phy;
+ unsigned int v_luma_phy;
+
+} b2r2_coeff_address;
+
+
+
+
+typedef struct
+{
+ unsigned int B2R2_NIP;
+ unsigned int B2R2_CIC;
+ unsigned int B2R2_INS;
+ unsigned int B2R2_ACK;
+
+} b2r2_system;
+
+typedef enum
+{
+ RGB565 = 0,
+ RGB888 = 1,
+ ARGB8565 = 4,
+ ARGB8888 = 5,
+ ARGB1555 = 6,
+ ARGB4444 = 7,
+ YCBCR888 = 16,
+ YCBCR422R = 18,
+ AYCBCR8888 = 21,
+ YCBCR42XMB = 20,
+ YCBCR42XR2B = 22,
+ YCBCR42XMBN = 14,
+ CLUT1 = 8,
+ CLUT2 = 9,
+ CLUT4 = 10,
+ CLUT8 = 11,
+ ACLUT44 = 12,
+ ACLUT88 = 13,
+ A1 = 24,
+ A8 = 25,
+ YUV = 30
+
+}b2r2_color_form;
+
+
+typedef struct
+{
+ unsigned int B2R2_TBA;
+ unsigned int B2R2_TTY;
+ unsigned int B2R2_TXY;
+ unsigned int B2R2_TSZ;
+
+}b2r2_target;
+
+
+typedef struct
+{
+ b2r2_color_form COLOR_FORM;
+ b2r2_win_size WIN_SIZE;
+ unsigned char MEM_ALIGHNMENT;
+
+}b2r2_format_win_size_para;
+
+
+typedef struct
+{
+ unsigned int B2R2_SBA;
+ unsigned int B2R2_STY;
+ unsigned int B2R2_SXY;
+ unsigned int B2R2_SSZ;
+
+}b2r2_src_config;
+
+
+typedef enum
+{
+ FCTL_CONFIG = 0, // FCTL Configuration enable only
+ PMK_CONFIG = 1, // PLANMASK Configuration enable
+ FCTL_PMK_EN = 2, // Enable both FCTL & PLANMASK
+
+}b2r2_fctl_pmk;
+
+
+
+typedef struct
+{
+ unsigned int HSRC_INIT :10;
+ unsigned int RESV1 :2;
+ unsigned int HNB_REPEAT :3;
+ unsigned int RESV2 :1;
+ unsigned int VSRC_INIT :10;
+ unsigned int RESV3 :2;
+ unsigned int VNB_REPEAT :3;
+ unsigned int RESV4 :1;
+
+}b2r2_rzi;
+
+
+typedef struct
+{
+ b2r2_rsf RSF;
+ b2r2_rzi RESIZE_INIT;
+ b2r2_filter_coeff FILTER_COEF;
+
+}b2r2_filter_para;
+
+
+
+typedef enum
+{
+ SAR_CONFIG_EN = 0, // Only SAR register configuration
+ USER_CONFIG_EN = 1, // Only User register configuration
+ SAR_USER_CONFIG_EN = 2, // Both SAR & User registers configuration
+
+}b2r2_sar_user;
+
+
+
+
+typedef struct
+{
+ unsigned char VM_FLAG; // This Flag indicate which VM will be used. if 'VM_FLAG =0' , output VM will be used & if 'VM_FLAG =1', input VM will be used.
+ unsigned int VM0; //VM0 coefficient. Please refer B2R2 spec for possible values.
+ unsigned int VM1; //VM1 coefficient. Please refer B2R2 spec for possible values & so on.
+ unsigned int VM2;
+ unsigned int VM3;
+
+}b2r2_versatile_matrix_reg;
+
+
+
+typedef struct
+{
+ b2r2_format_win_size_para SRC1_FORMAT_WIN_SIZE_PARA;
+ b2r2_format_win_size_para SRC2_FORMAT_WIN_SIZE_PARA;
+ b2r2_format_win_size_para SRC3_FORMAT_WIN_SIZE_PARA;
+ b2r2_format_win_size_para TARG_FORMAT_WIN_SIZE_PARA;
+ b2r2_win_pos SRC1_WIN_POS;
+ b2r2_win_pos SRC2_WIN_POS;
+ b2r2_win_pos SRC3_WIN_POS;
+ b2r2_win_pos TARG_WIN_POS;
+
+}b2r2_targ_three_src_color_size_pos_para;
+
+
+typedef struct
+{
+ unsigned int NODE_PT;
+ unsigned int NEXT_NODE_PT;
+ unsigned int SRC1_MEM_ADDR;
+ unsigned int SRC2_MEM_ADDR;
+ unsigned int SRC3_MEM_ADDR;
+ unsigned int TARG_MEM_ADDR;
+
+}b2r2_node_and_image_addr;
+
+
+typedef struct
+{
+ unsigned char B2R2_RED;
+ unsigned char B2R2_GREEN;
+ unsigned char B2R2_BLUE;
+ unsigned char COLOR_ALPHA;
+
+}b2r2_color_comp;
+
+typedef struct
+{
+ b2r2_color_form COLOR_FORM;
+ b2r2_win_size WIN_SIZE;
+ b2r2_color_comp COLOR_COMP;
+ unsigned char PITCH;
+
+}b2r2_colour_win_size_para;
+
+
+#define B2R2_GFX_COPY_NODESIZE (48)
+
+typedef struct
+{
+ unsigned short DIRECT_COPY :1 ; //Direct copy flag is applicable only with source1
+ unsigned short COLORFILL_EN :1 ; //Colorfil flag is applicable only with source1 & source2
+ unsigned short DIRECT_FILL :1 ;//Direct colorfil flag is applicable only with source1
+
+}b2r2_color_copy_flags;
+
+
+typedef struct
+{
+ unsigned int B2R2_S1CF;
+ unsigned int B2R2_S2CF;
+
+}b2r2_color_fill;
+
+
+typedef struct
+{
+ unsigned int NODE_PT; //Address of Node
+ unsigned int NEXT_NODE_PT; //Address of Next Node
+ unsigned int SRC_MEM_ADDR; //Address of source data
+ unsigned int TARG_MEM_ADDR; //Address of target location.
+
+}b2r2_node_src_targ_addr;
+
+
+typedef struct
+{
+ b2r2_format_win_size_para SRC_FORMAT_WIN_SIZE_PARA;
+ b2r2_format_win_size_para TARG_FORMAT_WIN_SIZE_PARA;
+ b2r2_win_pos SRC_WIN_POS;
+ b2r2_win_pos TARG_WIN_POS;
+ unsigned int COLOR_CONFIG;
+
+
+}b2r2_targ_one_src_color_size_pos_para;
+
+
+typedef enum
+{
+ ROT_90 = 1,
+ ROT_180 = 2,
+ ROT_270 = 3
+
+}b2r2_rot_type;
+
+
+typedef struct
+{
+
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_src_config GROUP345;
+
+}b2r2_copy_node;
+
+#define B2R2_ROTATE_NODE (48)
+
+/////////////////////////////////////////
+
+typedef struct
+{
+ unsigned int B2R2_CWO;
+ unsigned int B2R2_CWS;
+
+}b2r2_clip;
+
+typedef struct
+{
+ unsigned int B2R2_KEY1;
+ unsigned int B2R2_KEY2;
+
+}b2r2_color_key;
+
+typedef struct
+{
+ unsigned int B2R2_CCO;
+ unsigned int B2R2_CML;
+}b2r2_clut;
+
+typedef struct
+{
+ unsigned int B2R2_FCTL;
+ unsigned int B2R2_PMK;
+}b2r2_rsz_pl_mask;
+
+typedef struct
+{
+ unsigned int B2R2_RSF;
+ unsigned int B2R2_RZI;
+ unsigned int B2R2_HFP;
+ unsigned int B2R2_VFP;
+
+}b2r2_Cr_luma_rsz;
+
+typedef struct
+{
+ unsigned int B2R2_Coeff0;
+ unsigned int B2R2_Coeff1;
+ unsigned int B2R2_Coeff2;
+ unsigned int B2R2_Coeff3;
+
+}b2r2_flikr_filter;
+
+typedef struct
+{
+ unsigned int B2R2_XYL;
+ unsigned int B2R2_XYP;
+
+}b2r2_xyl;
+
+typedef struct
+{
+ unsigned int B2R2_SAR;
+ unsigned int B2R2_USR;
+ //unsigned int B2R2_RESERVED[2];
+
+}b2r2_sau;
+typedef struct
+{
+ unsigned int B2R2_VMX0;
+ unsigned int B2R2_VMX1;
+ unsigned int B2R2_VMX2;
+ unsigned int B2R2_VMX3;
+}b2r2_vm;
+typedef struct
+{
+
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_color_fill GROUP2;
+ b2r2_src_config GROUP3;
+ b2r2_src_config GROUP4;
+ b2r2_src_config GROUP5;
+ b2r2_clip GROUP6;
+ b2r2_clut GROUP7;
+ b2r2_rsz_pl_mask GROUP8;
+ b2r2_Cr_luma_rsz GROUP9;
+ b2r2_Cr_luma_rsz GROUP10;
+ b2r2_flikr_filter GROUP11;
+ b2r2_color_key GROUP12;
+ b2r2_xyl GROUP13;
+ b2r2_sau GROUP14;
+ b2r2_vm GROUP15;
+ b2r2_vm GROUP16;
+ unsigned int B2R2_RESERVED[2];
+
+}b2r2_link_list;
+
+/*************************************************************************************/
+/*************************************************************************************/
+/*************************************************************************************/
+/*************************************************************************************/
+/*******************tested unused protype*********************************************/
+/*************************************************************************************/
+/*************************************************************************************/
+/*************************************************************************************/
+/*************************************************************************************/
+/*************************************************************************************/
+/*************************************************************************************/
+#if 0
+
+#define B2R2_GFX_BLEND_NODESIZE (64)
+#define B2R2_GFX_CLIP_NODESIZE (64)
+
+
+
+typedef struct
+{
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_src_config GROUP3;
+ b2r2_clip GROUP6;
+
+}b2r2_rect_clip_without_color_fill;
+
+typedef struct
+{
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_color_fill GROUP2;
+ b2r2_src_config GROUP3;
+ b2r2_clip GROUP6;
+
+}b2r2_rect_clip_with_color_fill;
+
+
+
+typedef struct
+{
+ b2r2_one_src_without_color_fill src;
+ b2r2_color_key GROUP12;
+
+}b2r2_colour_key_colfill;
+
+typedef struct
+{
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_color_fill GROUP2;
+ b2r2_src_config GROUP3;
+}b2r2_fill_Rect;
+
+typedef struct
+{
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_src_config GROUP3;
+}b2r2_one_src_without_color_fill;
+
+typedef struct
+{
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_src_config GROUP3;
+ b2r2_src_config GROUP4;
+
+}b2r2_src1_src2_without_color_fill;
+
+
+typedef struct
+{
+
+ b2r2_system GROUP0;
+ b2r2_target GROUP1;
+ b2r2_color_fill GROUP2;
+ b2r2_src_config GROUP3;
+ b2r2_src_config GROUP4;
+
+}b2r2_src1_src2_with_color_fill;
+
+
+
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif /* _cplusplus */
+
+#endif /* !defined(__B2R2_GLOBAL_H) */ \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-24 15:07:18 +0000