summaryrefslogtreecommitdiff
path: root/b2r2_api.c
diff options
context:
space:
mode:
Diffstat (limited to 'b2r2_api.c')
-rw-r--r--b2r2_api.c1466
1 files changed, 1466 insertions, 0 deletions
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;
+}
+
+
+
+
+
+
+
+
+
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-06 02:35:16 +0000