void adc_pwrdown_disable(void)
{
#ifndef DRV_ADC_NOT_EXIST
#ifndef DRV_ADC_NO_PDN
#if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_DISABLE2(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
DRVPDN_Disable(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#endif /*ADC_DRVPDN_FAST*/
#else // #if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_DISABLE2(PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
//DRVPDN_Disable(PDN_ADC);
PDN_CLR(PDN_ADC);
L1SM_SleepDisable(ADCSM_handler);
#endif /*ADC_DRVPDN_FAST*/
#endif // #if defined(__OLD_PDN_ARCH__)
#endif //#ifdef DRV_ADC_NO_PDN
#endif // #ifndef DRV_ADC_NOT_EXIST
}
/* INPUT */
input.MK0 = (kal_int16) input_mk; /* LSB */
input.MK1 = (kal_int16)(input_mk >> 16); /* MSB */
input.DIRECTION = direction; /*decipher=1;cipher=0*/
key_ptr = (kal_uint8 *)&key;
DRVPDN_Disable(DRVPDN_CON0,DRVPDN_CON0_GCU,PDN_GCU);
GCU_InputData(&input);
if(cipher_algo == 1) /*A5_1 == 1*/
GCU_GEA1Start(); /* for uplink link. According to spec. 04.64 */
else if(cipher_algo == 2)
GCU_GEA2Start(); /* for uplink link. According to spec. 04.64 */
#if defined(DRV_GCU_GEA3)
else if(cipher_algo == 3)
GCU_GEA3Start();
#endif
else
ASSERT(0);
for(index1=0;index1 < ((buff_len+3)/4);index1++)
{
GCU_ReadKey(key);
for(index2=0;index2 < 4;index2++)
{
if((index1*4+index2) == buff_len)
break;
#if defined(DRV_GCU_GEA3) // Julie : GEA3 RBO reverse with bithe GEA1 and GEA2
if(cipher_algo == 3)
dest_buff_ptr[(index1*4+index2)] = src_buff_ptr[(index1*4+index2)] ^ key_ptr[3-index2];
else
dest_buff_ptr[(index1*4+index2)] = src_buff_ptr[(index1*4+index2)] ^ key_ptr[index2];
#else
dest_buff_ptr[(index1*4+index2)] = src_buff_ptr[(index1*4+index2)] ^ key_ptr[index2];
#endif
}
}
DRVPDN_Enable(DRVPDN_CON0,DRVPDN_CON0_GCU,PDN_GCU);
return KAL_TRUE;
}
#ifdef DRV_GCU_REV_BIT_DISABLE/*only 6218B has this, Others projects dont have*/
void GCU_Disable_ReverseBit(void)
{
DRVPDN_Disable(DRVPDN_CON0,DRVPDN_CON0_GCU,PDN_GCU);
// clear GCU reverse bit
DRV_Reg(GCU_CTRL) &= ~GCU_CTRL_RBO;
DRVPDN_Enable(DRVPDN_CON0,DRVPDN_CON0_GCU,PDN_GCU);
}
/*
* FUNCTION
* IMGPROC_Open
*
* DESCRIPTION
* Set owner of the IMGPROC. While one owner open the IMGPROC, no one
* is allowed to use IMGPROC untile the owern close it.
*
* CALLS
*
* PARAMETERS
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* imgproc_dcb.owner
*/
kal_int32 API IMGPROC_Open(MMDI_SCENERIO_ID owner)
{
#if (defined(DRV_IDP_6219_SERIES))
ENTER_CRITICAL();
ASSERT(imgproc_dcb.owner == SCENARIO_UNKNOW_ID);
imgproc_dcb.owner = owner;
EXIT_CRITICAL();
DRVPDN_Disable(DRVPDN_CON3,DRVPDN_CON3_IMGPROC,PDN_IMGPROC);
#endif
return NO_ERROR;
}
/*
* FUNCTION
* GPT_Start
*
* DESCRIPTION
* Start GPT timer
*
* CALLS
* It is called to start GPT timer
*
* PARAMETERS
* timerNum = 1(GPT1) or 2(GPT2)
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* external_global
*/
void GPT_Start(kal_uint8 timerNum)
{
if (timerNum == 1)
{
DRV_Reg(GPT1_CTRL) |= GPT_CTRL_Enable;
}
if (timerNum == 2)
{
DRV_Reg(GPT2_CTRL) |= GPT_CTRL_Enable;
}
#if defined(DRV_GPT_GPT3)
if (timerNum == 3)
{
DRV_Reg(GPT3_CTRL) |= GPT3_ENABLE;
}
#endif
#ifdef GPT_DRVPDN_FAST
DRVPDN_DISABLE2(DRVPDN_CON1,DRVPDN_CON1_GPT,PDN_GPT);
#else
DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_GPT,PDN_GPT);
#endif
IRQUnmask(IRQ_GPT_CODE);
}
/*************************************************************************
* FUNCTION
* GIF_Reset
*
* DESCRIPTION
* reset the gif decoder and control block
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
* gif_dcb
*************************************************************************/
void GIF_Reset(void)
{
DRVPDN_Disable(DRVPDN_CON3,DRVPDN_CON3_GIF,PDN_GIF);
GIF_RESET();
DRV_WriteReg32(GIF_STACK_BASE_ADDR, gif_resource.stack);
DRV_WriteReg32(GIF_TREE_BASE_ADDR, gif_resource.tree);
DRV_WriteReg32(GIF_GCT_BASE_ADDR, gif_resource.GCT);
DRV_WriteReg32(GIF_LCT_BASE_ADDR, gif_resource.LCT);
DRVPDN_Enable(DRVPDN_CON3,DRVPDN_CON3_GIF,PDN_GIF);
gif_dcb.out_location = GIF_MEMORY;
//gif_dcb.timeout_period = GIF_TIMEOUT_PERIOD;
gif_dcb.is_timeout = KAL_FALSE;
gif_dcb.frame_counter = 0;
gif_dcb.trailer = KAL_FALSE;
if(gif_dcb.gpt_handle == 0)
GPTI_GetHandle(&gif_dcb.gpt_handle);
kal_mem_set(&gif_dcb.gif_info,0,sizeof(gif_info_struct));
}
/*
* FUNCTION
* adc_pwrdown_disable
*
* DESCRIPTION
* This function is to disable adc power down control
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* Note that this function must be called between SaveAndSetIRQMask()
* and RestoreIRQMask().
*/
void adc_pwrdown_disable(void)
{
#ifndef DRV_ADC_NOT_EXIST
#if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_DISABLE2(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
DRVPDN_Disable(ADC_CG_PDN_CON_ADDR,ADC_CG_PDN_CON_BIT,PDN_ADC);
#endif /*ADC_DRVPDN_FAST*/
#else // #if defined(__OLD_PDN_ARCH__)
#ifdef ADC_DRVPDN_FAST
DRVPDN_DISABLE2(PDN_ADC);
#else /*ADC_DRVPDN_FAST*/
#if !defined(__DRV_SUPPORT_LPWR__)
PDN_CLR(PDN_ADC);
L1SM_SleepDisable(ADCSM_handler);
#else
DRVPDN_Disable(PDN_ADC);
#endif //#if !defined(__DRV_SUPPORT_LPWR__)
#endif /*ADC_DRVPDN_FAST*/
#endif // #if defined(__OLD_PDN_ARCH__)
#if defined(DRV_DIE_TO_DIE_INTERFACE)
{
kal_uint32 mask;
mask = SaveAndSetIRQMask();
auxadc_die2die_enable = KAL_TRUE;
PDN_CLR(PDN_ADC); // TP use the AuxADC PDN, make sure the PDN is disable
DRV_ADC_SetBits(ABB_WR_PATH0, F26M_CLK_EN); //enable clock for die to die interface, MT6250E1
//DRV_ADC_SetBits(ABB_RSV_CON1, AUXADC_FSM_CTRL|AUXADC_26M_CLK_CTRL); //enable clock for die to die interface, MT6250E2
DRV_ADC_SetBits(ABB_RSV_CON1, AUXADC_26M_CLK_CTRL); //enable clock for die to die interface, MT6250E2
ust_busy_wait(2);
DRV_ADC_SetBits(ABB_RSV_CON1, AUXADC_FSM_CTRL); //enable clock for die to die interface, MT6250E2
DRV_ADC_SetBits(0xa0160020,0x8000);
DRV_ADC_SetBits(ABBA_WR_PATH0, ABBA_AUX_PWDB); // enable clock for auxadc analog interface logic
DRV_ADC_SetBits(ABB_WR_PATH0, AUX_PWDB); //triggle die to die interface to send and receive auxadc data
ust_busy_wait(8);
DRV_ADC_SetBits(ABB_AUX_CON0, AUX_FIFO_CLK_EN); // auxadc fifo enable
DRV_ADC_SetBits(ABB_AUX_CON0, AUX_FIFO_EN); // auxadc fifo enable
RestoreIRQMask(mask);
}
#elif defined(DRV_DIE_TO_DIE_INTERFACE_V2)
{
DRV_ADC_SetBits(D2D_D_APC_AUX_CON1, D2D_D_F26M_AUX_EN);
DRV_ADC_SetBits(D2D_A_APC_AUD_CON1, D2D_A_AUX_EN);
DRV_ADC_Reg(D2D_A_APC_AUD_CON1);
DRV_ADC_SetBits(D2D_D_APC_AUX_CON1, D2D_D_AUX_EN|D2D_D_F26M_AUX_EN);
}
#endif
#endif // #ifndef DRV_ADC_NOT_EXIST
}
/*-----------------------------------------------------------------------*
*
* This function is to enable GPT source clock.
*
*------------------------------------------------------------------------*/
static void GPT_PDN_enable()
{
#if !defined(DRV_GPT_NO_PDN_BIT)
#if defined(__OLD_PDN_ARCH__)
#if defined(DRV_GPT_GPT_INTR_WAKEUP_SLEEP)
// Clear GPT PDN bit directly
#if defined(DRV_MISC_PDN_NO_SET_CLR)
#if defined(__OLD_PDN_DEFINE__)
DRV_GPT_ClearBits(DRVPDN_CON1, DRVPDN_CON1_GPT);
//DRV_GPT_Reg(DRVPDN_CON1) &= ~DRVPDN_CON1_GPT;
#elif defined(__CLKG_DEFINE__)
#if defined(DRV_GPT_NO_GPT_CG_BIT)
;
#else // #if defined(DRV_GPT_NO_GPT_CG_BIT)
ASSERT(0);
#endif // #if defined(DRV_GPT_NO_GPT_CG_BIT)
#endif // #if defined(__OLD_PDN_DEFINE__)
#else // #if defined(DRV_MISC_PDN_NO_SET_CLR)
#if defined(__OLD_PDN_DEFINE__)
DRV_GPT_WriteReg(DRVPDN_CON1_CLR, DRVPDN_CON1_GPT);
#elif defined(__CLKG_DEFINE__)
#if defined(DRV_GPT_NO_GPT_CG_BIT)
;
#else // #if defined(DRV_GPT_NO_GPT_CG_BIT)
ASSERT(0);
#endif // #if defined(DRV_GPT_NO_GPT_CG_BIT)
#endif // #if defined(__OLD_PDN_DEFINE__)
#endif // #if defined(DRV_MISC_PDN_NO_SET_CLR)
#else // #if defined(DRV_GPT_GPT_INTR_WAKEUP_SLEEP)
// We need to to hook sleep mode handler to disable MCU enter sleep mode
#if defined(__OLD_PDN_DEFINE__)
#if defined(DRV_GPT_DIRECT_SLEEP_MODE_HANDLE)
// Clear GPT PDN bit directly
#if defined(DRV_MISC_PDN_NO_SET_CLR)
DRV_GPT_ClearBits(DRVPDN_CON1, DRVPDN_CON1_GPT);
//DRV_GPT_Reg(DRVPDN_CON1) &= ~DRVPDN_CON1_GPT;
#else // #if defined(DRV_MISC_PDN_NO_SET_CLR)
DRV_GPT_WriteReg(DRVPDN_CON1_CLR, DRVPDN_CON1_GPT);
#endif // #if defined(DRV_MISC_PDN_NO_SET_CLR)
#else//#if defined(DRV_GPT_DIRECT_SLEEP_MODE_HANDLE)
#ifdef GPT_DRVPDN_FAST
DRVPDN_DISABLE2(DRVPDN_CON1,DRVPDN_CON1_GPT,PDN_GPT);
#else
DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_GPT,PDN_GPT);
#endif
#endif
#elif defined(__CLKG_DEFINE__)
#if defined(DRV_GPT_NO_GPT_CG_BIT)
#ifdef GPT_DRVPDN_FAST
// DRVPDN_DISABLE2(0,0,PDN_GPT); // TTTTTT, Temp commented for MT6268A DVT load
#else // #ifdef GPT_DRVPDN_FAST
DRVPDN_Disable(0,0,PDN_GPT);
#endif // #ifdef GPT_DRVPDN_FAST
#else // #if defined(DRV_GPT_NO_GPT_CG_BIT)
ASSERT(0); // TODO
#endif // #if defined(DRV_GPT_NO_GPT_CG_BIT)
#endif // #if defined(__OLD_PDN_DEFINE__)
#endif // #if defined(DRV_GPT_GPT_INTR_WAKEUP_SLEEP)
#else //#if defined(__OLD_PDN_ARCH__)
PDN_CLR(PDN_GPT);
#endif //#if defined(__OLD_PDN_ARCH__)
#endif //#if !defined(DRV_GPT_NO_PDN_BIT)
}
*************************************************************************/
kal_int32 GIF_Display_HW(gif_para_struct *s, gif_info_struct *info)
{
kal_uint8 *GIF_src, *GIF_end;
kal_uint32 n;
gif_disposal_enum gif_disposal;
kal_int32 status;
kal_uint32 *ptr;
//ENTER_CRITICAL();
ASSERT(gif_dcb.state == GIF_STATE_READY);
gif_dcb.state = GIF_STATE_BUSY;
//EXIT_CRITICAL();
if( (s->frame_number != 0)&&
(gif_dcb.frame_counter == 0)&&
(s->reset == KAL_FALSE))
ASSERT(0);
if( (s->clip_x1 > s->clip_x2)||
(s->clip_y1 > s->clip_y2))
return GIF_FINISH_FRAME;
//ASSERT(0);
if(s->reset || (s->frame_number == 0))
{
gif_dcb.img_adrs = s->img_adrs;
gif_dcb.current_adrs = s->img_adrs;
gif_dcb.img_end = s->img_adrs+s->img_size;
GIF_Reset();
}
if(gif_dcb.trailer )
{
status = GIF_NO_FRAME;
goto gif_display_end;
}
// initial guard pattern for stack and tree memorys(for every frame)
ptr = (kal_uint32*)(gif_resource.stack+gif_resource.stack_size-4);
*ptr = GIF_GUARD_PATTERN;
ptr = (kal_uint32*)(gif_resource.tree+gif_resource.tree_size-4);
*ptr = GIF_GUARD_PATTERN;
GIF_src = gif_dcb.current_adrs;
GIF_end = gif_dcb.img_end;
if(gif_dcb.frame_counter == 0)
{
// check gif header
if(GIF_src[0] != 'G' || GIF_src[1] != 'I' || GIF_src[2] != 'F')
{
status = GIF_FORMAT_ERROR;
goto gif_display_end;
}
n = GIF_src[10]; // pack field of LSD
GIF_src += 13;
/* skip the global color palette */
if(n&0x80)
{
n=1<<((n&0x7)+1); // GCT size
GIF_src += 3*n;
}
else
{
//dbg_print("!!!! NO GCT EXIST!!!!\r\n");
//ASSERT(0); // not exist of GCT
}
}
if(GIF_src >= (GIF_end))
{
status = GIF_NO_FRAME;
goto gif_display_end;
}
do
{
kal_uint16 w,h;
switch(*GIF_src++)
{
case '!': // 0x21
if(*GIF_src++==0xf9)
{ // Process the GIF extension block(GCE)
if(GIF_src[1]&0x01)
{
gif_dcb.gif_info.transparent_index = GIF_src[4];
gif_dcb.gif_info.transparent_flag = 1;
}
// use disposal method specified by gif file or user
if(s->disposal_force == GIF_MTK_NO_ACTION)
gif_disposal = (GIF_src[1]&0x1c)>>2;
else
gif_disposal = s->disposal_force;
//dbg_print("disposal %d!\r\n",gif_disposal);
// return delay time
gif_dcb.gif_info.delay_time = GIF_src[2];
GIF_src+=6;
}
else // skip other extensions
{
int offset;
while(1)
{
offset= *GIF_src++;
if(offset==0) break;
GIF_src += offset;
}
}
break;
case ',': // 0x2C, image descriptor
w = (kal_uint16)(GIF_src[5]<< 8)|(kal_uint16)GIF_src[4];
h = (kal_uint16)(GIF_src[7]<< 8)|(kal_uint16)GIF_src[6];
if(w*h*2 > s->work_size)
{
//dbg_print("working memory is not enough, WxH: %dx%d\r\n", w,h);
//ASSERT(0);
status = GIF_MEM_INSUFFICEITN;
goto gif_display_end;
}
gif_dcb.timeout_period = 100 * ((w*h)/(640*480)+1); // 1 second per (640x480)
GIF_src += 8;
// skip LCT if exist
n = *GIF_src++;
if(n&0x80)
{
n=1<<((n&0x7)+1);
GIF_src += n*3;
}
// skip LZW code size
GIF_src++;
// skip data blocks
do{
n = *GIF_src++;
GIF_src += n;
}while(n != 0);
// trigger hw decoder
DRVPDN_Disable(DRVPDN_CON3,DRVPDN_CON3_GIF,PDN_GIF);
if(gif_dcb.frame_counter == 0)
{
status = GIF_DecodeFirst(s->img_adrs,(void*)s->work_adrs, s->img_size);
}
else
{
status = GIF_DecodeNext((void*)s->work_adrs);
}
if(status < 0)
goto gif_display_end;
if(w != gif_dcb.gif_info.width ||
h != gif_dcb.gif_info.height)
{
status = GIF_HW_DECODE_FAIL;
goto gif_display_end;
}
if(status == GIF_LAST_FRAME)
{
gif_dcb.trailer = KAL_TRUE; // hardware detect the trailer
}
else if(GIF_src[0] == 0x3B||GIF_src[1] == 0x3B)
{
gif_dcb.trailer = KAL_TRUE; // software detect the trailer
}
if(/*gif_dcb.frame_counter == 0 || */gif_disposal == GIF_RESTORE_BG)
{
kal_bool tmp;
if(!s->decode_test)
{
tmp = GIF_G2D_FillBG(s,&gif_dcb.gif_info);
if( tmp == KAL_FALSE)
{
if(gif_dcb.trailer == KAL_TRUE)
status = GIF_LAST_FRAME;
else
status = GIF_OUT_OF_RANGE;
goto gif_display_end;
}
}
}
if(!s->decode_test)
GIF_G2D_BitBlt(s,&gif_dcb.gif_info);
if(s->frame_number == gif_dcb.frame_counter)
{
gif_dcb.frame_counter++;
gif_dcb.current_adrs = GIF_src;
if(gif_dcb.trailer == KAL_TRUE)
status = GIF_LAST_FRAME;
goto gif_display_end;
}
gif_dcb.frame_counter++;
break;
case ';': // 0x3b, trailer
//dbg_print("SW file finish!\r\n");
gif_dcb.trailer = KAL_TRUE;
status = GIF_LAST_FRAME;
goto gif_display_end;
break;
kal_bool gea_cidecipher (kal_uint8 *src_buff_ptr,
kal_uint8 *dest_buff_ptr,
kal_uint16 buff_len,
kal_uint8 cipher_algo,
kal_bool direction,
kal_uint8 *input_sk,
kal_uint32 input_mk)
{
kal_uint16 index1;
kal_uint16 index2;
kal_uint32 key;
kal_uint8 *key_ptr;
gcu_input input;
input.SK3 = input_sk[1] | (input_sk[0] << 8);
input.SK2 = input_sk[3] | (input_sk[2] << 8);
input.SK1 = input_sk[5] | (input_sk[4] << 8);
input.SK0 = input_sk[7] | (input_sk[6] << 8);
/* INPUT */
input.MK0 = (kal_int16) input_mk; /* LSB */
input.MK1 = (kal_int16)(input_mk >> 16); /* MSB */
input.DIRECTION = direction; /*decipher=1;cipher=0*/
key_ptr = (kal_uint8 *)&key;
DRVPDN_Disable(DRVPDN_CON0,DRVPDN_CON0_GCU,PDN_GCU);
GCU_InputData(&input);
if(cipher_algo == 1) /*A5_1 == 1*/
GCU_GEA1Start(); /* for uplink link. According to spec. 04.64 */
else if(cipher_algo == 2)
GCU_GEA2Start(); /* for uplink link. According to spec. 04.64 */
#if defined(DRV_GCU_GEA3)
else if(cipher_algo == 3)
GCU_GEA3Start();
#endif
else
ASSERT(0);
for(index1=0;index1 < ((buff_len+3)/4);index1++)
{
GCU_ReadKey(key);
for(index2=0;index2 < 4;index2++)
{
if((index1*4+index2) == buff_len)
break;
#if defined(DRV_GCU_GEA3) // Julie : GEA3 RBO reverse with bithe GEA1 and GEA2
if(cipher_algo == 3)
dest_buff_ptr[(index1*4+index2)] = src_buff_ptr[(index1*4+index2)] ^ key_ptr[3-index2];
else
dest_buff_ptr[(index1*4+index2)] = src_buff_ptr[(index1*4+index2)] ^ key_ptr[index2];
#else
dest_buff_ptr[(index1*4+index2)] = src_buff_ptr[(index1*4+index2)] ^ key_ptr[index2];
#endif
}
}
DRVPDN_Enable(DRVPDN_CON0,DRVPDN_CON0_GCU,PDN_GCU);
return KAL_TRUE;
}
