kal_bool USB_Ms_Read_Write(USB_MS_DIRECTION direct, kal_uint8 LUN, void *data, kal_uint32 LBA, kal_uint16 sec_len)
{
kal_bool ret;
kal_uint32 time;
kal_uint32 performance;
USB_Ms_Check_CURRENT_DRV(LUN);
if (USBMS_DISKDRV_LBA_INFO[LUN].LastBA == 0)
{
USBMS_DISKDRV_API[CURRENT_DRV][LUN]->usbms_read_capacity(
&USBMS_DISKDRV_LBA_INFO[LUN].LastBA,
&USBMS_DISKDRV_LBA_INFO[LUN].BlkLen);
}
if ( (LBA+sec_len-1) > USBMS_DISKDRV_LBA_INFO[LUN].LastBA)
return KAL_FALSE;
time = drv_get_current_time();
if (direct == USB_MS_WRITE)
ret = USBMS_DISKDRV_API[CURRENT_DRV][LUN]->usbms_write(data, LBA, sec_len);
else
ret = USBMS_DISKDRV_API[CURRENT_DRV][LUN]->usbms_read(data, LBA, sec_len);
time = drv_get_current_time()-time;
if(time > 0)
{
performance = sec_len*32*1024/2/time;
if (direct == USB_MS_WRITE)
drv_trace1(TRACE_FUNC, (kal_uint32)USBMS_WRITE_PERFORMANCE, performance);
else
drv_trace1(TRACE_FUNC, (kal_uint32)USBMS_READ_PERFORMANCE, performance);
}
return ret;
}
/**
* ROTDMA warm reset function.
*
* @param none.
*
* @return.
*/
void rotdma0_warm_reset(void)
{
kal_uint32 irq_flag;
kal_uint32 cfg;
// First backup control register due to control register would be clear after warm reset
irq_flag = REG_IMGDMA_ROT_DMA_IRQ_FLAG & 0xFFFF0000;
cfg = REG_IMGDMA_ROT_DMA_CFG;
IMGDMA_ROTDMA_WARM_RESET();
{
kal_bool rst_done;
kal_uint32 last_time = drv_get_current_time();
// Check if rotdma reset busy, if busy over 2 tick, assert... according to Andy, < 4us (200 cycle @52Mhz)
do
{
rst_done = IMGDMA_ROTDMA_IS_WARM_RESET_FINISH();
} while ((KAL_FALSE == rst_done) &&
(2 >= drv_get_duration_tick(last_time, drv_get_current_time())));
}
// Restore control register
REG_IMGDMA_ROT_DMA_IRQ_FLAG = irq_flag;
REG_IMGDMA_ROT_DMA_CFG = cfg;
}
void adc_delay_us(kal_uint32 us)
{
kal_uint32 tmp;
kal_uint32 tick_count;
tick_count = us>>5; // The unit is 32us
//tick_count = us/32; // The unit is 32us
tmp = drv_get_current_time();
while (drv_get_duration_tick(tmp, drv_get_current_time()) < tick_count)
{
;
}
}
/* determine what buffer has data to send and call DMA setup function*/
void USB2UART_DMATransmit(kal_uint8 ep_num, kal_bool b_force_isr_buffer)
{
kal_uint32 addr;
kal_uint32 length=0;
// kal_uint32 savedMask;
// savedMask = SaveAndSetIRQMask();
if(b_force_isr_buffer == KAL_TRUE)
{
length = USB2UART_Check_Transmit_Data(&addr, KAL_FALSE);
}
else
{
length = USB2UART_Check_Transmit_Data(&addr, g_UsbACM.threshold_enable);
}
// RestoreIRQMask(savedMask);
if (length)
{
USB_Dbg_Trace(USB_ACM_DMA_SETUP, drv_get_current_time(), length, USB2Uart_MemType);
/* dma running state is cleared by USB2UART_Tx_DMA_Callback */
// USB_DMA_Setup(ep_num, USB_TX_EP_TYPE, addr, length, USB2UART_Tx_DMA_Callback, KAL_TRUE);
USB_DMA_Setup(ep_num, USB_TX_EP_TYPE, USB_ENDPT_BULK, addr, length, USB2UART_Tx_DMA_Callback, KAL_FALSE, KAL_TRUE, USB_DMA1_TYPE);
}
else
{
g_UsbACM.setup_dma = KAL_FALSE;
}
}
MM_ERROR_CODE_ENUM HdrCtrl (PP_SCENARIO_ENUM ScenarioId, PP_SCENARIO_CTRL_ENUM CtrlCode,
void *pParaIn, void *pParaOut, kal_uint16 ParaOutLen)
{
kal_uint32 i, StartTime, TotalTime=0;
UTL_SWITCH_CACHE_STRUCT MemSwitch;
if(PP_CTRL_CODE_STOP == CtrlCode)
{
PP_SET_EVENT(PP_EVENT_HDR_STOP_CNF);
}
else if(PP_CTRL_CODE_START == CtrlCode)
{
StartTime = drv_get_current_time();
gHdrProcPara.MaxProcTime = HDR_PROCESS_MAX_TIME;
MemSwitch.pMemAddr= (kal_uint32*)&(gHdrProcPara.SrcImgAddr);
MemSwitch.Size = gHdrProcPara.SrcImgSize;
MemSwitch.CacheableFlag=KAL_TRUE;
UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL);
MemSwitch.pMemAddr= (kal_uint32*)&(gHdrProcPara.WorkingBufAddr);
MemSwitch.Size = SwHdrGetUseWorkingBufferSize();
MemSwitch.CacheableFlag=KAL_TRUE;
UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL);
for(i=0;i<HDR_PROCESS_MAX_COUNT;i++)
{
/* HDR process */
SwHdrCoreProc(&gHdrProcPara, &gHdrProcResult, ParaOutLen);
/* Evaluated process time */
TotalTime = drv_get_duration_ms(StartTime);
if((HDR_PROCESS_MAX_TIME<=TotalTime)||(HDR_STATE_READY==gHdrProcResult.HdrState))
{
break;
}
else
{
gHdrProcPara.MaxProcTime = HDR_PROCESS_MAX_TIME - TotalTime;
}
}
if(gHdrProcResult.HdrState == HDR_STATE_READY)
{
MemSwitch.pMemAddr= (kal_uint32*)&gHdrProcResult.ImgBufferAddr;
MemSwitch.Size = (gHdrProcResult.ImgWidth*gHdrProcResult.ImgHeight*3)/2;//gHdrProcPara.SrcImgSize;
MemSwitch.CacheableFlag=KAL_FALSE;
UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL);
MemSwitch.pMemAddr= (kal_uint32*)&(gHdrProcPara.WorkingBufAddr);
MemSwitch.Size = SwHdrGetUseWorkingBufferSize();
MemSwitch.CacheableFlag=KAL_FALSE;
UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL);
pfPpHdrCb(PP_CBID_HDR_RESULT, &gHdrProcResult, sizeof(HDR_RESULT_STRUCT));
}
}
return MM_ERROR_NONE;
} /* SwHdrControl() */
void MT6302_spiPowerCtrl(kal_bool on)
{
kal_uint32 i;
if(0 == MT6302_getSPIInterface())
{
if(31 < MT6302_LCD_pdnHandle)
ASSERT(0);
if (KAL_FALSE == on)
lcd_clk_disable(MT6302_LCD_pdnHandle);
else if(KAL_TRUE == on){
lcd_clk_enable(MT6302_LCD_pdnHandle);
if(DRVPDN_CON1_LCD & DRV_Reg(DRVPDN_CON1))
ASSERT(0);
i = 1000;
while(i)
i--;
}
else
ASSERT(0);
}
else if(1 == MT6302_getSPIInterface())
{
/*we don't know should we do power control before want to write SPI in GPIO implementation*/
}
else{
IMPLEMENTING_ASSERT;
}
drv_trace8(TRACE_GROUP_4, SIM_GEMINI_GEN1, FILE_MT6302_SPI, __LINE__,
on, DRV_Reg(DRVPDN_CON1), MT6302_getSPIInterface(), MT6302_LCD_pdnHandle,
drv_get_current_time(), 0
);
}
kal_uint32 drv_get_duration_ms(kal_uint32 previous_time)
{
kal_uint32 result;
kal_uint32 current_time;
current_time = drv_get_current_time();
result = drv_get_duration_tick(previous_time, current_time);
result*=1000;
result/=32768;
return result;
}
kal_uint32 drv_get_duration_ms(kal_uint32 previous_time)
{
kal_uint32 result;
kal_uint32 current_time;
kal_uint64 temp_value;
current_time = drv_get_current_time();
result = drv_get_duration_tick(previous_time, current_time);
/* X ms = result x 1000/32K = (result x 125)>>12 */
temp_value = (kal_uint64)(((kal_uint64) result)*125);
result = (kal_uint32)(temp_value>>12);
return result;
}
void
idp_add_traced_end(IdpTracedAPI const api, kal_int32 const idx)
{
if ((idx < 0) || (idx >= IDP_TRACED_BUFFER_SIZE))
{
ASSERT(0);
}
if (g_idp_traced[idx].m_api != api)
{
ASSERT(0);
}
g_idp_traced[idx].m_done = KAL_TRUE;
g_idp_traced[idx].m_done_time_drv = drv_get_current_time();
}
kal_int32
idp_add_traced_lisr(IdpTracedAPI const api)
{
kal_uint32 savedMask;
kal_uint32 register my_idx;
savedMask = SaveAndSetIRQMask();
my_idx = g_idp_traced_curr_idx;
++g_idp_traced_curr_idx;
g_idp_traced_curr_idx &= (IDP_TRACED_BUFFER_SIZE - 1);
RestoreIRQMask(savedMask);
g_idp_traced[my_idx].m_api = api;
g_idp_traced[my_idx].m_start_time_drv = drv_get_current_time();
return my_idx;
}
void DRV_HISR(void)
{
kal_uint16 index;
kal_uint32 savedMask;
#if defined(_MAUI_SOFTWARE_LA_)
/* under construction !*/
#endif
if (drv_hisr_status != 0)
{
for(index = 0;index<MAX_DRV_HISR_DEVICE;index++)
{
if (drv_hisr_status & (1 << index))
{
savedMask = SaveAndSetIRQMask();
#if defined(_MAUI_SOFTWARE_LA_)
/* under construction !*/
/* under construction !*/
#endif
DRV_CURRENT_HISR = index;
#if ( defined(MT6218B) || defined(MT6205B) )
drv_hisr_dbg_trace(index, 0xffff);
#else /*! (MT6218B, MT6205B)*/
drv_hisr_dbg_trace(index, drv_get_current_time());
#endif /*(MT6218B, MT6205B)*/
ASSERT(DRV_HISR_TABLE[index].hisr_count!=0);
DRV_HISR_TABLE[index].hisr_count--;
if (DRV_HISR_TABLE[index].hisr_count == 0)
drv_hisr_status &= ~((1 << index));
RestoreIRQMask(savedMask);
DRV_HISR_TABLE[index].hisr_func();
DRV_CURRENT_HISR = DRV_UNKNOWN_HISR_ID;
}
}
}
}
static void USB_Stdcmd(Usb_Ep0_Status *pep0state, Usb_Command *pcmd)
{
kal_bool bError = KAL_FALSE;
switch (pcmd->bRequest)
{
case USB_SET_ADDRESS:
USB_Dbg_Trace(USB_EP0_SET_ADDRESS, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_SetAddress(pep0state, pcmd);
break;
case USB_GET_DESCRIPTOR:
USB_Dbg_Trace(USB_EP0_GET_DESCRIPTOR, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_GetDescriptor(pep0state, pcmd);
break;
case USB_SET_CONFIGURATION:
USB_Dbg_Trace(USB_EP0_SET_CONFIGURATION, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_SetConfiguration(pep0state, pcmd);
break;
case USB_SET_INTERFACE:
USB_Dbg_Trace(USB_EP0_SET_INTERFACE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_SetInterface(pep0state, pcmd);
break;
case USB_GET_CONFIGURATION:
USB_Dbg_Trace(USB_EP0_GET_CONFIGURATION, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_GetConfiguration(pep0state, pcmd);
break;
case USB_GET_INTERFACE:
USB_Dbg_Trace(USB_EP0_GET_INTERFACE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_GetInterface(pep0state, pcmd);
break;
case USB_SET_FEATURE:
USB_Dbg_Trace(USB_EP0_SET_FEATURE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_SetFeature(pcmd, KAL_TRUE);
break;
case USB_CLEAR_FEATURE:
USB_Dbg_Trace(USB_EP0_CLEAR_FEATURE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_SetFeature(pcmd, KAL_FALSE);
break;
case USB_GET_STATUS:
USB_Dbg_Trace(USB_EP0_GET_STATUS, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = USB_Cmd_GetStatus(pep0state, pcmd);
break;
/* Stall the command if an unrecognized request is received */
case USB_SYNCH_FRAME: /*Only support for Isoc traffic*/
case USB_SET_DESCRIPTOR:
default:
USB_Dbg_Trace(USB_EP0_CMD_ERROR, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex);
bError = KAL_TRUE;
// ASSERT(0);
break;
}
if (gUsbDevice.ep0_state == USB_EP0_IDLE) /* no data to transmit */
{
gUsbDevice.ep0_state = USB_EP0_RX_STATUS;
USB_Update_EP0_State(USB_EP0_DRV_STATE_READ_END, bError, KAL_TRUE);
/*
if((gUsbDevice.ep0_class_cmd_handler.b_enable == KAL_TRUE) &&
(gUsbDevice.ep0_class_cmd_handler.cmd == pcmd->bRequest) )
{
gUsbDevice.ep0_class_cmd_handler.ep0_cmd_hdlr(pcmd);
}
*/
}
else
{
USB_Update_EP0_State(USB_EP0_DRV_STATE_READ_END, bError, KAL_FALSE);
}
}
/*put bytes to tx buffer, return value is the actually put out bytes*/
static kal_uint16 USB2UART_PutBytes(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length, module_type ownerid)
{
kal_uint16 real_count;
// kal_uint16 index;
kal_uint32 savedMask;
kal_uint8 ep_num = 0;
kal_bool setup_dma = KAL_FALSE;
kal_int32 remain;
BUFFER_INFO *tx_info = &(USB2UARTPort.Tx_Buffer);
if(ownerid != USB2UARTPort.ownerid)
{
#ifdef __PRODUCTION_RELEASE__
return 0;
#else /* __PRODUCTION_RELEASE__ */
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
#endif
}
/* return directly if not match condition */
if ( (gUsbDevice.device_type != USB_CDC_ACM) ||
(USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG))
{
if(((gUsbDevice.device_type == USB_CDC_ACM)||(gUsbDevice.usb_comport_boot == KAL_TRUE))
&& (USB2UARTPort.initialized == KAL_TRUE)&&(gUsbDevice.nDevState != DEVSTATE_CONFIG))
{
g_UsbACM.config_send_Txilm = KAL_TRUE; /* for PC set config later then can issue the first message */
}
return 0;
}
/* The same issue as USB2UART_GetBytes()
The area to determine send_Txilm must also contain in critical section.
Otherwise if DMA callback activated before send_Txilm setting as true,
this message will be lost */
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_info, real_count);
/* determine real sent data count */
if (real_count > length)
{
real_count = length;
}
else
{
g_UsbACM.send_Txilm = KAL_TRUE; /*After this time put bytes, buffer will be full */
g_UsbACM.config_send_Txilm = KAL_TRUE; /* if be reseted, then it can issue the message waited for*/
}
RestoreIRQMask(savedMask);
if(g_UsbACM.send_Txilm == KAL_TRUE)
{
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_PUT_BYTES_BUF_FULL, ownerid);
// kal_prompt_trace(MOD_USB, "RDY W %d", ownerid);
}
}
if(real_count != 0)
{
remain = (BWrite(tx_info) + real_count) - BLength(tx_info);
if(remain < 0)
{
/* dest, src, len */
kal_mem_cpy(BuffWrite(tx_info), buffaddr, real_count);
BWrite(tx_info) += real_count;
}
else
{
kal_mem_cpy(BuffWrite(tx_info), buffaddr, real_count-remain);
kal_mem_cpy(BStartAddr(tx_info), (kal_uint8 *)(buffaddr+real_count-remain), remain);
BWrite(tx_info) = remain;
}
}
/* push data from caller buffer to ring buffer */
/*
for (index = 0; index < real_count; index++)
{
Buf_Push(&(USB2UARTPort.Tx_Buffer), *(buffaddr+index));
}
*/
savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section */
if(gUsbDevice.device_type == USB_CDC_ACM)
{
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
if(g_UsbACM.setup_dma == KAL_FALSE)
{
g_UsbACM.setup_dma = KAL_TRUE;
setup_dma = KAL_TRUE;
ep_num = g_UsbACM.txpipe->byEP;
}
}
RestoreIRQMask(savedMask);
if(setup_dma == KAL_TRUE)
{
USB_Dbg_Trace(USB_ACM_DMA_SETUP_1, drv_get_current_time(), ep_num, 0);
USB2UART_DMATransmit(ep_num, KAL_FALSE);
}
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0);
}
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_PUT_BYTES, real_count);
// kal_prompt_trace(MOD_USB, "Put %d", real_count);
}
#endif
return real_count;
}
static void USB2UART_CtrlDCD(UART_PORT port, IO_level SDCD, module_type ownerid)
{
kal_uint32 savedMask;
kal_bool b_set_intr;
kal_uint8 ep_num = 0;
#ifdef USB_20_ENABLE
kal_uint32 max_intr_pkt_size;
#endif
#ifndef __PRODUCTION_RELEASE__
USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT, drv_get_current_time(), g_UsbACM.intr_state, 0);
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
}
#endif
savedMask = SaveAndSetIRQMask();
if((g_UsbACM.intr_state == ACM_INTR_IDLE)&&(gUsbDevice.is_configured_now == KAL_TRUE))
{
b_set_intr = KAL_TRUE;
g_UsbACM.is_intr_pending_pkt = KAL_FALSE;
ep_num = g_UsbACM.intrpipe->byEP;
}
else
{
b_set_intr = KAL_FALSE;
g_UsbACM.is_intr_pending_pkt = KAL_TRUE;
}
if(SDCD == io_high)
g_UsbACM.intr_pkt.Data = SERIAL_STATE_BRXCARRIER;
else if (SDCD == io_low)
g_UsbACM.intr_pkt.Data = 0x00;
else
ASSERT(0);
RestoreIRQMask(savedMask);
if(b_set_intr == KAL_TRUE)
{
#ifdef USB_20_ENABLE
if(USB_Is_High_Speed() == KAL_TRUE)
max_intr_pkt_size = USB_EP_INTR_MAXP_HS;
else
max_intr_pkt_size = USB_EP_INTR_MAXP_FS;
if(max_intr_pkt_size > sizeof(UsbAcm_Intr_Pkt))
#else
if(USB_EP_INTR_MAXP > sizeof(UsbAcm_Intr_Pkt))
#endif
{
g_UsbACM.intr_state = ACM_INTR_SEND_LAST_PKT;
#ifndef __PRODUCTION_RELEASE__
/* send only one short packet */
USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT2, drv_get_current_time(), g_UsbACM.intr_state, 0);
drv_trace1(TRACE_FUNC, USBACM_INTR, g_UsbACM.intr_pkt.Data);
// kal_prompt_trace(MOD_USB, "ACM INTR %d", g_UsbACM.intr_pkt.Data);
#endif
USB_EPFIFOWrite(ep_num, sizeof(UsbAcm_Intr_Pkt), (kal_uint8 *)&g_UsbACM.intr_pkt);
USB_EP_Bulk_Tx_Ready(ep_num);
}
else
{
g_UsbACM.intr_state = ACM_INTR_SEND_ONE_PKT;
#ifndef __PRODUCTION_RELEASE__
/* send one max packet */
USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT1, drv_get_current_time(), g_UsbACM.intr_state, 0);
drv_trace1(TRACE_FUNC, USBACM_INTR, g_UsbACM.intr_pkt.Data);
// kal_prompt_trace(MOD_USB, "ACM INTR %d", g_UsbACM.intr_pkt.Data);
#endif
#ifdef USB_20_ENABLE
USB_EPFIFOWrite(ep_num, max_intr_pkt_size, (kal_uint8 *)&g_UsbACM.intr_pkt);
#else
USB_EPFIFOWrite(ep_num, USB_EP_INTR_MAXP, (kal_uint8 *)&g_UsbACM.intr_pkt);
#endif
USB_EP_Bulk_Tx_Ready(ep_num);
}
}
}
/* put bytes to ISR tx buffer, handle the special character in this function(add escape character)
return value is the actually put out bytes*/
static kal_uint16 USB2UART_SendISRData(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length,
kal_uint8 mode, kal_uint8 escape_char, module_type ownerid)
{
kal_int16 real_count, index;
kal_uint8 data;
kal_uint32 savedMask;
kal_uint8 ep_num = 0;
kal_bool setup_dma = KAL_FALSE;
BUFFER_INFO *tx_isr_info = &(USB2UARTPort.Tx_Buffer_ISR);
if(ownerid != USB2UARTPort.ownerid)
{
#ifdef __PRODUCTION_RELEASE__
return 0;
#else
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
#endif
}
if ( (gUsbDevice.device_type != USB_CDC_ACM) ||
(USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG))
return 0;
if (mode == 0)
{
real_count = USB2UART_PutISRBytes(port, buffaddr, length, ownerid);
}
else
{
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_isr_info, real_count);
RestoreIRQMask(savedMask);
/* determine real sent data count */
if (real_count > length)
real_count = length;
for (index = 0; index < real_count; index++)
{
kal_uint16 roomleft;
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_isr_info, roomleft);
RestoreIRQMask(savedMask);
data = *(buffaddr + index);
/* if the character is special character, translate it. PC has the ability to distinguish it*/
if (data == USB2UARTPort.DCB.xonChar)
{
if ( roomleft >= 2 )
{
Buf_Push(tx_isr_info, escape_char);
Buf_Push(tx_isr_info, 0x01);
}
else
{
break;
}
}
else if (data == USB2UARTPort.DCB.xoffChar)
{
if ( roomleft >= 2 )
{
Buf_Push(tx_isr_info, escape_char);
Buf_Push(tx_isr_info, 0x02);
}
else
{
break;
}
}
else if (data == escape_char)
{
if ( roomleft >= 2 )
{
Buf_Push(tx_isr_info, escape_char);
Buf_Push(tx_isr_info, 0x03);
}
else
{
break;
}
}
else
{
if (roomleft)
{
Buf_Push(tx_isr_info, data);
}
else
{
break;
}
}
}
real_count = index;
savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section */
if(gUsbDevice.device_type == USB_CDC_ACM)
{
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
if(g_UsbACM.setup_dma == KAL_FALSE)
{
g_UsbACM.setup_dma = KAL_TRUE;
setup_dma = KAL_TRUE;
ep_num = g_UsbACM.txpipe->byEP;
}
}
RestoreIRQMask(savedMask);
if(setup_dma == KAL_TRUE)
{
USB_Dbg_Trace(USB_ACM_DMA_SETUP_3, drv_get_current_time(), ep_num, 0);
USB2UART_DMATransmit(ep_num, KAL_FALSE);
}
}
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0);
}
#endif
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_SEND_ISR_DATA, real_count);
// kal_prompt_trace(MOD_USB, "SendISR %d", real_count);
}
return real_count;
}
/* put bytes to ISR tx buffer, return value is the actually put out bytes */
static kal_uint16 USB2UART_PutISRBytes(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length, module_type ownerid)
{
kal_uint16 real_count;
// kal_uint16 index;
kal_uint32 savedMask;
kal_uint8 ep_num = 0;
kal_bool setup_dma = KAL_FALSE;
kal_int32 remain;
BUFFER_INFO *tx_isr_info = &(USB2UARTPort.Tx_Buffer_ISR);
if(ownerid != USB2UARTPort.ownerid)
{
#ifdef __PRODUCTION_RELEASE__
return 0;
#else /* __PRODUCTION_RELEASE__ */
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
#endif
}
if ( (gUsbDevice.device_type != USB_CDC_ACM) ||
(USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG))
return 0;
savedMask = SaveAndSetIRQMask();
Buf_GetRoomLeft(tx_isr_info, real_count);
RestoreIRQMask(savedMask);
/* determine real sent data count */
if (real_count > length)
real_count = length;
if(real_count != 0)
{
remain = (BWrite(tx_isr_info) + real_count) - BLength(tx_isr_info);
if(remain < 0)
{
/* dest, src, len */
kal_mem_cpy(BuffWrite(tx_isr_info), buffaddr, real_count);
BWrite(tx_isr_info) += real_count;
}
else
{
kal_mem_cpy(BuffWrite(tx_isr_info), buffaddr, real_count-remain);
kal_mem_cpy(BStartAddr(tx_isr_info), (kal_uint8 *)(buffaddr+real_count-remain), remain);
BWrite(tx_isr_info) = remain;
}
}
/* push data from caller buffer to ring buffer */
/*
for (index = 0; index < real_count; index++)
{
Buf_Push(tx_isr_info, *(buffaddr+index));
}
*/
savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section */
if(gUsbDevice.device_type == USB_CDC_ACM)
{
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
if(g_UsbACM.setup_dma == KAL_FALSE)
{
g_UsbACM.setup_dma = KAL_TRUE;
setup_dma = KAL_TRUE;
ep_num = g_UsbACM.txpipe->byEP;
}
}
RestoreIRQMask(savedMask);
if(setup_dma == KAL_TRUE)
{
USB_Dbg_Trace(USB_ACM_DMA_SETUP_2, drv_get_current_time(), ep_num, 0);
USB2UART_DMATransmit(ep_num, KAL_FALSE);
}
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0);
}
#endif
if(ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_PUT_ISR_BYTES, real_count);
// kal_prompt_trace(MOD_USB, "PutISR %d", real_count);
}
return real_count;
}
usim_status_enum L1sim_Reset_All(sim_power_enum ExpectVolt, sim_power_enum *ResultVolt, kal_bool warm, SIM_ICC_APPLICATION application)
{
sim_ctrlDriver *simDriver;
usim_status_enum status;
kal_uint32 simInterface;
#ifdef __SIM_HOT_SWAP_SUPPORT__
kal_int32 ipcStatus;
#if defined (__MD1__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
kal_uint8 *query, querystring[25] = "MD1_SIM1_HOT_PLUG_EINT";
#elif defined (__MD2__)
kal_uint8 *query, querystring[25] = "MD2_SIM1_HOT_PLUG_EINT";
#else
kal_uint8 *query, querystring[20] = "SIM1_HOT_PLUG_EINT";
#endif
SIM_ICC_HOT_PLUG iccHotPlug = {KAL_FALSE, KAL_FALSE, KAL_FALSE, 0, 0, 0, 0, 0, 0, NULL, NULL};
query = &querystring[0];
#endif
#ifdef SIM_4_CARD_SMT_TEST
SIM_ICC_APPLICATION anotherApplication;
kal_uint32 anotherSimInterface;
sim_power_enum anotherResultVolt;
sim_ctrlDriver *anotherSimDriver;
usim_status_enum anotherStatus;
#endif
sim_HW_cb *hw_cb;
simInterface = sim_get_logicalNum_from_app(application);
hw_cb = (sim_HW_cb *)(hwCbArray[simInterface]);
#ifdef SIM_4_CARD_SMT_TEST
if(SIM_ICC_APPLICATION_PHONE1 == application)
anotherApplication = SIM_ICC_APPLICATION_PHONE3;
else if(SIM_ICC_APPLICATION_PHONE2 == application)
anotherApplication = SIM_ICC_APPLICATION_PHONE4;
else
ASSERT(0);
anotherSimInterface = sim_get_logicalNum_from_app(anotherApplication);
#endif
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= simInterface)
ASSERT(0);
#ifdef SIM_4_CARD_SMT_TEST
if(DRV_SIM_MAX_LOGICAL_INTERFACE <= anotherSimInterface)
ASSERT(0);
#endif
if(KAL_TRUE == sim_physicalSlotChanged){
#if !defined( __MAUI_BASIC__)
tst_sys_trace("[SIM]:sim interface inversed!!");
#else
dbg_print("[SIM]:sim interface inversed!!");
#endif
simInterface = 1-simInterface;
application = 1-application; // need to switch to get correct hwcb and SIMIF number
}
if(0x0 == ResultVolt)
ASSERT(0);
#if defined (LPWR_SLIM)
L1SM_SleepDisable(hw_cb->smHandler); //lock sleep mode
#endif
#ifdef __CUSTOMER_HW_VERIFICATION__
simInterface = 0;
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
sim_MT6302_addMsg(SIM_MT6302_ACTION_RESET, simInterface, 0, 0);
status = simDriver->reset(ExpectVolt, ResultVolt, warm, (sim_HW_cb *)(hwCbArray[simInterface]));
sim_MT6302_addMsg(SIM_MT6302_ACTION_EOC, simInterface, drv_get_current_time(), 0);
simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface]));
simInterface = 1;
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
sim_MT6302_addMsg(SIM_MT6302_ACTION_RESET, simInterface, 0, 0);
/*when we release single SIM MMI, we only release SIM1 MMI, cusrtomer won't get SIM2 MMI, SIM1 is what MMI need*/
//status = simDriver->reset(ExpectVolt, ResultVolt, warm, simInterface);
sim_MT6302_addMsg(SIM_MT6302_ACTION_EOC, simInterface, drv_get_current_time(), 0);
simDriver->EOC(simInterface);
#else
/*find out the hooked function table*/
simDriver = sim_driverTable[simInterface];
ASSERT(0 != simDriver);
simDriver->addMessage(SIM_AL_ACTION_RESET, simInterface, (kal_uint32)kal_get_current_thread_ID(), 0);
status = simDriver->reset(ExpectVolt, ResultVolt, warm, (sim_HW_cb *)(hwCbArray[simInterface]));
#ifdef __SIM_HOT_SWAP_SUPPORT__
/* we should always register eint. If we bootup without plugin simcard, status will display NO_CARD.
we will never get insert event because eint is not registered */
#if defined (__MD1__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
if (application == SIM_ICC_APPLICATION_PHONE2)
query = (kal_uint8 *)"MD1_SIM2_HOT_PLUG_EINT";
#elif defined (__MD2__)
if (application == SIM_ICC_APPLICATION_PHONE2)
query = (kal_uint8 *)"MD2_SIM2_HOT_PLUG_EINT";
#else
if (application == SIM_ICC_APPLICATION_PHONE2)
query = (kal_uint8 *)"SIM2_HOT_PLUG_EINT";
#endif
/* if any rpc error happens, we should leave register eint */
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_NUMBER, (void *)&iccHotPlug.eintNo, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_NUMBER, (void *)&iccHotPlug.eintNo, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get eint no fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.eintNo);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_DEBOUNCETIME, (void *)&iccHotPlug.debounceTime, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_DEBOUNCETIME, (void *)&iccHotPlug.debounceTime, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get debounce fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.debounceTime);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_POLARITY, (void *)&iccHotPlug.polarity, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_POLARITY, (void *)&iccHotPlug.polarity, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get polarity fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.polarity);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_SENSITIVITY, (void *)&iccHotPlug.sensitivity, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_SENSITIVITY, (void *)&iccHotPlug.sensitivity, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get sensitivity fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.sensitivity);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
#if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__)
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_SOCKETTYPE, (void *)&iccHotPlug.socketType, 4);
#else
ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_SOCKETTYPE, (void *)&iccHotPlug.socketType, 4);
#endif
if (ipcStatus < 0)
{
kal_sprintf(sim_dbg_str,"get socket fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.socketType);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
goto LEAVE_REG_EINT;
}
sim_reg_hot_plug_eint(application, iccHotPlug.eintNo, iccHotPlug.debounceTime, iccHotPlug.polarity, iccHotPlug.sensitivity, iccHotPlug.socketType);
LEAVE_REG_EINT:
kal_sprintf(sim_dbg_str,"[SIM_DRV]EINT: %d, %d %d %d %d %d %d", application, ipcStatus, iccHotPlug.eintNo, iccHotPlug.debounceTime, iccHotPlug.polarity, iccHotPlug.sensitivity, iccHotPlug.socketType);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
kal_sprintf(sim_dbg_str,"[SIM_DRV]EINT: %s", query);
#if !defined( __MAUI_BASIC__)
tst_sys_trace(sim_dbg_str);
#else
dbg_print(sim_dbg_str);
#endif
#endif /* End of #ifdef __SIM_HOT_SWAP_SUPPORT__ */
simDriver->addMessage(SIM_AL_ACTION_EOC, simInterface, 0, 0);
simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface]));
#ifdef SIM_4_CARD_SMT_TEST
/*find out the hooked function table*/
anotherSimDriver = sim_driverTable[anotherSimInterface];
ASSERT(0 != anotherSimDriver);
anotherSimDriver->addMessage(SIM_AL_ACTION_RESET, anotherSimInterface, (kal_uint32)kal_get_current_thread_ID(), 0);
anotherStatus = anotherSimDriver->reset(UNKNOWN_POWER_CLASS, &anotherResultVolt, warm, (sim_HW_cb *)(hwCbArray[anotherSimInterface]));
if(USIM_NO_ERROR == anotherStatus)
{
#if !defined( __MAUI_BASIC__)
tst_sys_trace("another SIM card found!!");
#else
dbg_print("another SIM card found!!");
#endif
}
else
{
#if !defined( __MAUI_BASIC__)
tst_sys_trace("another SIM card not found!!");
#else
dbg_print("another SIM card not found!!");
#endif
}
anotherSimDriver->addMessage(SIM_AL_ACTION_EOC, anotherSimInterface, 0, 0);
anotherSimDriver->EOC((sim_HW_cb *)(hwCbArray[anotherSimInterface]));
#endif
#endif
#if defined (LPWR_SLIM)
L1SM_SleepEnable(hw_cb->smHandler); //unlock sleep mode
#endif
return status;
}
static S32 mmi_em_profiling_gdi_misc_speed_sw_fill_rect(void *v_param)
{
static const U32 PROFILING_MS = 4000;
gdi_handle layer;
S32 i;
U32 start_time, duration;
mmi_em_profiling_gdi_misc_speec_fill_rect_param *param =
(mmi_em_profiling_gdi_misc_speec_fill_rect_param*)v_param;
kal_int32 fill_x, fill_y, fill_width, fill_height;
gdi_color fill_color;
layer = mmi_em_profiling_gdi_create_layer(
param->layer.cf, param->layer.x, param->layer.y, param->layer.width, param->layer.height);
if (layer == 0)
{
return -1;
}
gdi_layer_push_and_set_active(layer);
gdi_layer_clear(GDI_COLOR_BLACK);
gdi_layer_pop_and_restore_active();
fill_x = param->fill.x;
fill_y = param->fill.y;
fill_width = param->fill.width;
fill_height = param->fill.height;
fill_color = gdi_cf_get_color(param->layer.cf, 255, 255, 255, 255);
gdi_layer_push_and_set_active(layer);
MMI_TRACE(MMI_COMMON_TRC_INFO, TRC_APP_EM_PROFILING_GDI_FRECT_START);
start_time = drv_get_current_time();
i = 0;
do
{
do
{
gdi_draw_solid_rect(
fill_x, fill_y, fill_width, fill_height, fill_color);
i++;
}
while ((i & 0xf) != 0); /* Calculate duration every 16 iterations */
duration = drv_get_duration_ms(start_time);
}
#ifdef __MTK_TARGET__
while (duration < PROFILING_MS);
#else
while (0);
#endif
MMI_TRACE(MMI_COMMON_TRC_INFO, TRC_APP_EM_PROFILING_GDI_FRECT_END, param->id, i, duration);
gdi_layer_pop_and_restore_active();
gdi_layer_blt(
layer,
0,
0,
0,
0,
0,
GDI_LCD_WIDTH - 1,
GDI_LCD_HEIGHT - 1);
mmi_em_profiling_gdi_free_layer(layer);
return 0;
}
kal_uint32 F32K_Get_FQMTR_DATA_For_EOSC32_Trimming(kal_uint16 eosccal_value, kal_uint16 winset)
{
kal_uint16 reg_value, reg_xosccal_value;
kal_uint32 FQMTR_DATA, wait_count, latency_time_start;
DCL_HANDLE rtc_handler;
RTC_CTRL_WRITE_OSC32CON_REG_T rtc_osc32_con;
reg_xosccal_value = DRV_F32K_Reg(RTC_XOSCCAL);
reg_xosccal_value &= ~0x1f;
reg_xosccal_value |= eosccal_value;
rtc_handler = DclRTC_Open(DCL_RTC, FLAGS_NONE);
rtc_osc32_con.OSC32CON_Reg = reg_xosccal_value;
DclRTC_Control(rtc_handler, RTC_CMD_WRITE_OSC32CON_REG, (DCL_CTRL_DATA_T *)&rtc_osc32_con);
DclRTC_Close(rtc_handler);
reg_value = FQMTR_RST;
DRV_F32K_WriteReg(FQMTR_CON0, reg_value); // Stop freq-meter
/* latency time (of FQMTR_BUSY bit eable) is 2 tick time of fixed clock
fixed clock is EOSC32 clock
*/
latency_time_start = drv_get_current_time(); // 32k clock time tick
wait_count = 0;
while(wait_count < 0xffffffff)
{
if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick
break;
wait_count++;
}
#if defined(DRV_F32K_FQMTR_AS_6255)
while(DRV_F32K_Reg(FQMTR_CON2) & FQMTR_BUSY);
reg_value = FQMTR_EN | winset;
DRV_F32K_WriteReg(FQMTR_CON0, reg_value); // start freq-meter
#elif defined(DRV_F32K_FQMTR_AS_6250)
while(DRV_F32K_Reg(FQMTR_CON0) & FQMTR_BUSY);
reg_value = winset;
DRV_F32K_WriteReg(FQMTR_CON3, reg_value); // start freq-meter
reg_value = FQMTR_EN;
DRV_F32K_WriteReg(FQMTR_CON0, reg_value); // start freq-meter
#endif
/* latency time (of FQMTR_BUSY bit eable) is 2 tick time of fixed clock
fixed clock is EOSC32 clock
*/
latency_time_start = drv_get_current_time(); // 32k clock time tick
wait_count = 0;
while(wait_count < 0xffffffff)
{
if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick
break;
wait_count++;
}
#if defined(DRV_F32K_FQMTR_AS_6255)
while(DRV_F32K_Reg(FQMTR_CON2) & FQMTR_BUSY);
#elif defined(DRV_F32K_FQMTR_AS_6250)
while(DRV_F32K_Reg(FQMTR_CON0) & FQMTR_BUSY);
#endif
/* latency time (of get fqmtr_data ) is 1 tick time of test clock
test clock is 13M clock
*/
latency_time_start = drv_get_current_time();
wait_count = 0;
while(wait_count<0xffffffff)
{
if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 10) // 10 32K tick
break;
wait_count++;
}
#if defined(DRV_F32K_FQMTR_AS_6255)
//FQMTR_DATA = ((DRV_F32K_Reg(FQMTR_CON3)&0x7fff)<<15)|((DRV_F32K_Reg(FQMTR_CON2)&0x7fff));
FQMTR_DATA = DRV_F32K_Reg(FQMTR_CON2)&0x7fff;
#elif defined(DRV_F32K_FQMTR_AS_6250)
FQMTR_DATA = DRV_F32K_Reg(FQMTR_CON2);
#endif
return FQMTR_DATA;
}
static void drv_reg_dbg_trace(kal_uint8 write, kal_uint16 line, kal_uint32 addr, kal_uint32 value)
{
DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].write_flag = write;
DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].line_number = line;
DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].reg_addr = addr;
DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].reg_value = value;
DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].time_log = drv_get_current_time();
DRV_REG_DBG_INFO_DATA.dbg_data_idx++;
}
kal_int32
idp_add_traced_begin(IdpTracedAPI const api)
{
kal_uint32 savedMask;
kal_int32 my_idx;
#if defined(ENABLE_LOGGING_FOR_IS_BUSY)
kal_int32 my_idx_minus_1;
kal_int32 my_idx_minus_2;
#endif
#if !defined(ENABLE_LOGGING_FOR_IS_BUSY)
switch (api)
{
case IDP_TRACED_API_camera_preview_IS_BUSY:
case IDP_TRACED_API_camera_preview_with_face_detection_IS_BUSY:
case IDP_TRACED_API_camera_capture_to_jpeg_IS_BUSY:
case IDP_TRACED_API_camera_capture_to_mem_IS_BUSY:
case IDP_TRACED_API_camera_capture_to_barcode_IS_BUSY:
case IDP_TRACED_API_jpeg_decode_IS_BUSY:
case IDP_TRACED_API_jpeg_encode_IS_BUSY:
case IDP_TRACED_API_jpeg_resize_IS_BUSY:
case IDP_TRACED_API_image_resize_IS_BUSY:
case IDP_TRACED_API_rgb2yuv_IS_BUSY:
case IDP_TRACED_API_video_editor_decode_IS_BUSY:
case IDP_TRACED_API_video_editor_encode_IS_BUSY:
case IDP_TRACED_API_video_decode_IS_BUSY:
case IDP_TRACED_API_video_encode_IS_BUSY:
case IDP_TRACED_API_webcam_IS_BUSY:
case IDP_TRACED_API_video_call_decode_IS_BUSY:
case IDP_TRACED_API_video_call_encode_IS_BUSY:
case IDP_TRACED_API_simple_display_with_rotate_IS_BUSY:
case IDP_TRACED_API_image_effect_pixel_IS_BUSY:
return -1;
//break;
default:
break;
}
#endif
savedMask = SaveAndSetIRQMask();
{
my_idx = g_idp_traced_curr_idx;
#if defined(ENABLE_LOGGING_FOR_IS_BUSY)
// I don't want the same xxx_IS_BUSY fill out of my
// g_idp_traced space.
switch (my_idx)
{
case 0:
my_idx_minus_1 = (IDP_TRACED_BUFFER_SIZE - 1);
my_idx_minus_2 = (IDP_TRACED_BUFFER_SIZE - 2);
break;
case 1:
my_idx_minus_1 = 0;
my_idx_minus_2 = (IDP_TRACED_BUFFER_SIZE - 1);
break;
default:
my_idx_minus_1 = (my_idx - 1);
my_idx_minus_2 = (my_idx - 2);
break;
}
switch (api)
{
case IDP_TRACED_API_camera_preview_IS_BUSY:
case IDP_TRACED_API_camera_preview_with_face_detection_IS_BUSY:
case IDP_TRACED_API_camera_capture_to_jpeg_IS_BUSY:
case IDP_TRACED_API_camera_capture_to_mem_IS_BUSY:
case IDP_TRACED_API_camera_capture_to_barcode_IS_BUSY:
case IDP_TRACED_API_camera_capture_to_ybuffer_IS_BUSY:
case IDP_TRACED_API_jpeg_decode_IS_BUSY:
case IDP_TRACED_API_jpeg_encode_IS_BUSY:
case IDP_TRACED_API_jpeg_resize_IS_BUSY:
case IDP_TRACED_API_image_resize_IS_BUSY:
case IDP_TRACED_API_rgb2yuv_IS_BUSY:
case IDP_TRACED_API_video_editor_decode_IS_BUSY:
case IDP_TRACED_API_video_editor_encode_IS_BUSY:
case IDP_TRACED_API_video_decode_IS_BUSY:
case IDP_TRACED_API_video_encode_IS_BUSY:
case IDP_TRACED_API_webcam_IS_BUSY:
case IDP_TRACED_API_video_call_decode_IS_BUSY:
case IDP_TRACED_API_video_call_encode_IS_BUSY:
case IDP_TRACED_API_simple_display_with_rotate_IS_BUSY:
case IDP_TRACED_API_image_effect_pixel_IS_BUSY:
if ((api == g_idp_traced[my_idx_minus_1].m_api) &&
(api == g_idp_traced[my_idx_minus_2].m_api))
{
RestoreIRQMask(savedMask);
return my_idx_minus_1;
}
break;
default:
break;
}
#endif
++g_idp_traced_curr_idx;
g_idp_traced_curr_idx &= (IDP_TRACED_BUFFER_SIZE - 1);
}
RestoreIRQMask(savedMask);
g_idp_traced[my_idx].m_api = api;
g_idp_traced[my_idx].m_who = kal_get_current_thread_ID();
if (kal_if_hisr())
{
g_idp_traced[my_idx].m_call_by_which_level = IDP_CALL_BY_HISR;
}
else if (kal_if_lisr())
{
g_idp_traced[my_idx].m_call_by_which_level = IDP_CALL_BY_LISR;
}
else
{
g_idp_traced[my_idx].m_call_by_which_level = IDP_CALL_BY_TASK;
}
g_idp_traced[my_idx].m_done = KAL_FALSE;
g_idp_traced[my_idx].m_start_time_drv = drv_get_current_time();
return my_idx;
}
void F32K_Switch_32K_setting(void)
{
kal_uint16 reg_value, fqmtr_data, f32k_md_status;
kal_uint32 wait_count, latency_time_start;
// read MD CHIP STATUS register
f32k_md_status = DRV_F32K_Reg(F32K_MD_CHIP_STATUS);
// init FIXED clock = PAD_32K, TESTED clock= 26MHZ
reg_value = FQMTR_FCKSEL_PAD32K | FQMTR_TCKSEL_CLKSSQ26M;
DRV_F32K_WriteReg(FQMTR_CON1, reg_value);
// reset FQMTR
DRV_F32K_WriteReg(FQMTR_CON0, FQMTR_RST);
latency_time_start = drv_get_current_time(); // 32k clock time tick
wait_count = 0;
while(wait_count < 0xffffffff)
{
if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick
break;
wait_count++;
}
while(DRV_F32K_Reg(FQMTR_CON1) & FQMTR_BUSY);
// set WINSET and enable FQMTR
reg_value = FQMTR_EN | F32K_FQMTR_WINSET;
DRV_F32K_WriteReg(FQMTR_CON0, reg_value);
latency_time_start = drv_get_current_time(); // 32k clock time tick
wait_count = 0;
while(wait_count < 0xffffffff)
{
if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick
break;
wait_count++;
}
while(DRV_F32K_Reg(FQMTR_CON1) & FQMTR_BUSY);
latency_time_start = drv_get_current_time();
wait_count = 0;
while(wait_count<0xffffffff)
{
if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 10) // 10 32K tick
break;
wait_count++;
}
fqmtr_data = DRV_F32K_Reg(FQMTR_CON3);
if ((f32k_md_status & F32K_SYS_PAD32K_BOND_EN) == F32K_SYS_PAD32K_BOND_EN)
{
if ((FQMTR_PAD32K_LOWER_BOUND < fqmtr_data) && (fqmtr_data < FQMTR_PAD32K_UPPER_BOUND))
{
// chip is System pad_32K bonding and PAD_32K exist
DRV_F32K_WriteReg32(F32K_AP_F32K_SEL, F32K_AP_PAD32K_CK_EN);
}
else
{
// chip is System pad_32K bonding but PAD_32K don't exist
ASSERT(0);
}
}
else
{
if ((FQMTR_PAD32K_LOWER_BOUND < fqmtr_data) && (fqmtr_data < FQMTR_PAD32K_UPPER_BOUND))
{
// chip isn't System pad_32K bonding and PAD_32K exist
DRV_F32K_WriteReg32(F32K_AP_F32K_SEL, F32K_AP_PAD32K_CK_EN);
}
}
// reset FQMTR to default value
DRV_F32K_WriteReg(FQMTR_CON1, FQMTR_CON0_DEFAULT_VAL);
DRV_F32K_WriteReg(FQMTR_CON0, FQMTR_CON1_DEFAULT_VAL);
}
void lcd_HISR(void)
{
#if (!defined(MT6205B)&&!defined(MT6208))
kal_uint32 save_irq_mask;
kal_uint8 i;
volatile kal_uint16 j;
#if !defined(DRV_IDP_SUPPORT)
#ifdef MT6225_IDP_DEBUG
dbg_time3=drv_get_current_time();
kal_prompt_trace(MOD_BMT,"lcd int= %d", dbg_time3);
#endif
kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_transfer_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
if (bWaitForLCDUpdate==KAL_TRUE)
{ /* for software udpate only */
bWaitForLCDUpdate=KAL_FALSE;
if (main_lcd_operation_state==LCD_SW_UPDATE_STATE)
main_lcd_operation_state=LCD_STANDBY_STATE;
#ifdef DUAL_LCD
if (sub_lcd_operation_state==LCD_SW_UPDATE_STATE)
sub_lcd_operation_state=LCD_STANDBY_STATE;
#endif
config_lcd_layer_window_queue();
if (lcd_prev_run_block_cb!=NULL)
lcd_prev_run_block_cb();
}
IRQUnmask(IRQ_LCD_CODE);
#elif defined(DRV_IDP_SUPPORT)
if (current_update_lcd==MAIN_LCD)
{
if (lcd_transfer_complete==KAL_TRUE)
{
if ((main_lcd_operation_state==LCD_SW_UPDATE_STATE)||
(main_lcd_operation_state==LCD_WAIT_LAST_UPDATE_STATE)||
(main_lcd_operation_state==LCD_MEM_UPDATE_STATE))
{
kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR);
#ifdef __VIDEO_EDITOR__
/*video editor*/
if(is_video_editor_running()==KAL_TRUE)
{
video_editor_data_path2();
main_lcd_operation_state=temp_main_lcd_operation_state;
}
#endif
}
save_irq_mask=SaveAndSetIRQMask();
lcd_transfer_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
if (bWaitForLCDUpdate==KAL_TRUE)
{ /* for software udpate only */
bWaitForLCDUpdate=KAL_FALSE;
if (main_lcd_operation_state==LCD_SW_UPDATE_STATE)
main_lcd_operation_state=LCD_STANDBY_STATE;
config_lcd_layer_window_queue();
if (lcd_prev_run_block_cb!=NULL)
lcd_prev_run_block_cb();
}
}
if (lcd_cmd_latch_complete==KAL_TRUE)/*set TRUE in LCD_LISR*/
{
if (lcd_hw_trigger_flag==KAL_TRUE)
{
#ifdef TV_OUT_SUPPORT
if ((tv_output_owner == TV_OUT_OWNER_LCD) && (tv_output_buffer_count<2))
{
IRQUnmask(IRQ_LCD_CODE);
return;
}
#endif
lcd_hw_trigger_flag=KAL_FALSE;
if ((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||/*back to video size*/
(main_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
{
for (j=0;j<50;j++);
#ifdef TV_OUT_SUPPORT
if (tv_output_owner == TV_OUT_OWNER_LCD)
{
if (tv_out_current_fb==0)
lcd_mem_out_address_shadow1=main_lcd_fb_update_para.tv_output_frame_buffer1_address;
else
lcd_mem_out_address_shadow1=main_lcd_fb_update_para.tv_output_frame_buffer2_address;
}
#endif
DRV_WriteReg32(LCD_ROI_CTRL_REG,lcd_hw_trigger_roi_ctrl);
DRV_WriteReg32(LCD_ROI_OFFSET_REG,lcd_hw_trigger_roi_offset);
DRV_WriteReg32(LCD_ROI_SIZE_REG,lcd_hw_trigger_roi_size);
#ifdef TV_OUT_SUPPORT
DRV_WriteReg32(LCD_ROI_WMEM_ADDR_REG,lcd_mem_out_address_shadow1);
#endif
for (i=0;i<LCD_CMD_QUEUE_LENGTH;i++)
*((volatile unsigned int *) (LCD_CMD_PARAMETER_ADDR+(i<<2)))=lcd_hw_trigger_para[i];
#ifdef __SYNC_LCM_SW_SUPPORT__
if ((sync_lcm_enable_mode==KAL_TRUE)&&
((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)))
{
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
else
{
START_LCD_TRANSFER;
for (j=0;j<30;j++);
}
#else
START_LCD_TRANSFER;
for (j=0;j<30;j++);
#endif
}
else
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
#ifdef TV_OUT_SUPPORT
if (tv_output_owner!=TV_OUT_OWNER_LCD) {
DISABLE_LCD_TRANSFER_COMPLETE_INT;
}
#else
DISABLE_LCD_TRANSFER_COMPLETE_INT;
#endif
}
else /*lcd_hw_trigger_flag==KAL_FALSE*/
{
if ((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(main_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
{
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
}
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
}
}
#ifdef TV_OUT_SUPPORT
if (tv_output_buffer_rotate==1)
{
#if defined(DRV_TVOUT_6228_SERIES)
g2d_tv_output_src_buff.base_address=tv_output_buffer_base_address1;
g2d_bitblt1(G2D_OWNER_LCD, &g2d_tv_output_bitblt);
#elif defined(DRV_TVOUT_6238_SERIES)
//KKKKK,OK
//not necessary in 6238 because we use IRT3
#endif
tv_output_buffer_rotate=0;
}
else if (tv_output_buffer_rotate==2)
{
#if defined(DRV_TVOUT_6228_SERIES)
g2d_tv_output_src_buff.base_address=tv_output_buffer_base_address2;
g2d_bitblt1(G2D_OWNER_LCD,&g2d_tv_output_bitblt);
#elif defined(DRV_TVOUT_6238_SERIES)
//KKKKK,OK
//not necessary in 6238 because we use IRT3
#endif
tv_output_buffer_rotate=0;
}
#endif
#ifdef DUAL_LCD/*almost the same as the main LCD part, except TVout.*/
else if (current_update_lcd==SUB_LCD)
{
if (lcd_transfer_complete==KAL_TRUE)
{
if ((sub_lcd_operation_state==LCD_SW_UPDATE_STATE)||
(sub_lcd_operation_state==LCD_WAIT_LAST_UPDATE_STATE))
kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_transfer_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
if (bWaitForLCDUpdate==KAL_TRUE)
{ /* for software udpate only */
bWaitForLCDUpdate=KAL_FALSE;
if (sub_lcd_operation_state==LCD_SW_UPDATE_STATE)
sub_lcd_operation_state=LCD_STANDBY_STATE;
config_lcd_layer_window_queue();
if (lcd_prev_run_block_cb!=NULL)
lcd_prev_run_block_cb();
}
}
if (lcd_cmd_latch_complete==KAL_TRUE)
{
if (lcd_hw_trigger_flag==KAL_TRUE)
{
lcd_hw_trigger_flag=KAL_FALSE;
if ((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
{
for (j=0;j<100;j++);
DRV_WriteReg32(LCD_ROI_CTRL_REG,lcd_hw_trigger_roi_ctrl);
DRV_WriteReg32(LCD_ROI_OFFSET_REG,lcd_hw_trigger_roi_offset);
DRV_WriteReg32(LCD_ROI_SIZE_REG,lcd_hw_trigger_roi_size);
for (i=0;i<LCD_CMD_QUEUE_LENGTH;i++)
DRV_WriteReg32(LCD_CMD_PARAMETER_ADDR+(i<<2),lcd_hw_trigger_para[i]);
#ifdef __SYNC_LCM_SW_SUPPORT__
if ((sync_lcm_enable_mode==KAL_TRUE)&&
((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)))
{
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
else
{
START_LCD_TRANSFER;
for (j=0;j<30;j++);
}
#else
START_LCD_TRANSFER;
for (j=0;j<30;j++);
#endif
}
else
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
#ifdef TV_OUT_SUPPORT
if (tv_output_owner!=TV_OUT_OWNER_LCD) {
DISABLE_LCD_TRANSFER_COMPLETE_INT;
}
#else
DISABLE_LCD_TRANSFER_COMPLETE_INT;
#endif
}
else
{
if ((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)||
(sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)||
(sub_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE))
kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR);
save_irq_mask=SaveAndSetIRQMask();
lcd_cmd_latch_complete=KAL_FALSE;
RestoreIRQMask(save_irq_mask);
}
}
}
#endif /* DUAL_LCD */
IRQUnmask(IRQ_LCD_CODE);
#endif /* MT6219 */
#endif /* MT6219 */
} /* lcd_HISR() */
kal_uint16 ADC_GetData(kal_uint8 sel)
{
#if defined(DRV_ADC_NOT_EXIST)
return 0;
#endif // #if defined(DRV_ADC_NOT_EXIST)
#ifndef DRV_ADC_NOT_EXIST
#if defined(DRV_ADC_MODEM_SIDE)
kal_uint32 saved_current_time = 0;
#endif
kal_uint16 data;
#if !defined(ADC_REMOVE_IRQMASK)
kal_uint32 savedMask;
#endif //#if !defined(ADC_REMOVE_IRQMASK)
#if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
kal_uint32 savedMask2;
#endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
adc_channel_number_check(sel);
#if defined(DRV_ADC_NO_IMM) || defined(FPGA)
ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask();
adc_pwrdown_disable();
#ifndef DRV_ADC_MODEM_SIDE
DRV_ADC_WriteReg(AUXADC_CTRL,sel);
#endif // #ifndef DRV_ADC_MODEM_SIDE
adc_imm_mode_cnt++;
ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask);
while(!(DRV_ADC_Reg(AUXADC_STAT) & AUXADC_STAT_RDY));
data = DRV_ADC_Reg(AUXADC_DATA);
#endif /*(DRV_ADC_NO_IMM,FPGA)*/
#if defined(DRV_ADC_IMM)
ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask();
adc_imm_mode_cnt++;
adcsche_adc_measure_en(KAL_TRUE);
ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask);
#if defined(__DRV_ADC_PMIC_TURN_ON_MEASURE_DELAY__)
if((ADC_VBAT == sel) ||
(ADC_VISENSE == sel) ||
(ADC_VCHARGER == sel))
{
kal_sleep_task(1); //delay 2 frames for HEPHAESTUS68 need delay to measure
}
#endif //#if defined(__DRV_ADC_PMIC_TURN_ON_MEASURE_DELAY__)
ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask();
adc_pwrdown_disable();
#if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
{
savedMask2 = SaveAndSetIRQMask();
}
#endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
#if defined(DRV_ADC_VCHARGER_EXTEND_READING)
if(ADC_VCHARGER == sel)
{
DRV_ADC_SetBits(MIX_ABB_base + 0x0b00,0x01f0); //extend to MAX ticks while reading
}
#endif
#ifdef DRV_ADC_SET_CLR
DRV_ADC_SetBits(AUXADC_CON1_CLR, (1<<sel));
DRV_ADC_SetBits(AUXADC_CON1_SET, (1<<sel));
#else
DRV_ADC_WriteReg(AUXADC_IMM, 0);
adc_dummy_read();
//DRV_ADC_Reg(AUXADC_IMM) = 0;
DRV_ADC_SetBits(AUXADC_IMM, (1<<sel));
//DRV_ADC_Reg(AUXADC_IMM) |= (1<<sel);
#endif
ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask);
#if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
{
volatile kal_uint32 tmp_32;
for (tmp_32=20;tmp_32!=0;tmp_32--){
;
}
}
#endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
#if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
{
RestoreIRQMask(savedMask2);
}
#endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA)
#if !defined(DRV_MISC_IGNORE_ADC_RUN_STATUS_CHECK)
#if defined(DRV_ADC_MODEM_SIDE)
{
kal_uint32 i;
for(i=100;i!=0;i--);
while((DRV_ADC_Reg(AUXADC_DAT(sel)) & 0x1000) == 0x1000);
}
#else
adc_check_busy_bit();
#endif
#endif // #if !defined(DRV_MISC_IGNORE_ADC_RUN_STATUS_CHECK)
data = (DRV_ADC_Reg(AUXADC_DAT(sel)) & 0x0FFF);
#if defined(DRV_ADC_MODEM_SIDE)
saved_current_time = drv_get_current_time();
while(drv_get_duration_tick(saved_current_time, drv_get_current_time()) <= 2) // 64us
{
;// Polling 32K reference clock
}
#endif
#endif /*DRV_ADC_IMM*/
ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask();
adc_imm_mode_cnt--;
if ((((kal_uint16)adc_imm_mode_cnt) == 0) && (((kal_bool)adc_sync_mode_on) == KAL_FALSE))
{
adc_pwrdown_enable();
}
ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask);
ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask();
if ((((kal_uint16)adc_imm_mode_cnt) == 0) && (((kal_bool)adc_sync_mode_on) == KAL_FALSE))
{
#if !defined(DRV_ADC_MODEM_SIDE) //don't write pmu bit to 0
adcsche_adc_measure_en(KAL_FALSE);
#endif
}
ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask);
return data;
#endif // #ifndef DRV_ADC_NOT_EXIST
}
U32 OS_GetSystemTime(void)
{
return drv_get_current_time();
}
/* DMA callback function for TX sent out data */
static void USB2UART_Tx_DMA_Callback(void)
{
kal_uint32 savedMask;
kal_uint8 ep_num = 0;
kal_bool setup_dma = KAL_FALSE;
kal_bool b_force_isr_buffer = KAL_FALSE;
if(USB2UARTPort.ownerid != MOD_TST_READER)
{
drv_trace1(TRACE_FUNC, USBACM_DMA_CALLBACK, USB2Uart_WriteLength);
// kal_prompt_trace(MOD_USB, "DMA %d", USB2Uart_WriteLength);
}
/* tx complete callback*/
USB2UARTPort.tx_cb(uart_port_usb);
#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
/*update read pointer for previously sent out buffer */
savedMask = SaveAndSetIRQMask();
USB2UART_Update_Transmit_Data();
RestoreIRQMask(savedMask);
/* USB2Uart_MemType and USB2Uart_WriteLength are updated, so clear dma running state here*/
g_UsbACM.setup_dma = KAL_FALSE;
// USB_DMA_Set_Run_Status(g_UsbACM.txpipe->byEP, KAL_FALSE);
if(USB2UARTPort.Tx_Buffer_ISR.Read == USB2UARTPort.Tx_Buffer_ISR.Write)
{
/* no more data to send */
if(USB2UARTPort.Tx_Buffer.Read == USB2UARTPort.Tx_Buffer.Write)
return;
}
/* must send ISR buffer again */
else if(USB2Uart_MemType == USBTRX_MEM_ISR)
{
b_force_isr_buffer = KAL_TRUE;
}
/* send data again in TX buffer or TXISR buffer */
savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section */
if(gUsbDevice.device_type == USB_CDC_ACM)
{
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
if(g_UsbACM.setup_dma == KAL_FALSE)
{
g_UsbACM.setup_dma = KAL_TRUE;
setup_dma = KAL_TRUE;
ep_num = g_UsbACM.txpipe->byEP;
}
}
RestoreIRQMask(savedMask);
if(setup_dma == KAL_TRUE)
{
USB_Dbg_Trace(USB_ACM_DMA_CALLBACK, drv_get_current_time(), ep_num, 0);
USB2UART_DMATransmit(ep_num, b_force_isr_buffer);
}
// savedMask = SaveAndSetIRQMask();
/* in case usb is plugged out just before this critical section*/
// if(gUsbDevice.device_type == USB_CDC_ACM)
// {
// if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE)
// {
// USB2UART_DMATransmit(g_UsbACM.txpipe->byEP);
// }
// }
// RestoreIRQMask(savedMask);
}
MM_ERROR_CODE_ENUM FdCtrl(PP_SCENARIO_ENUM ScenarioId, PP_SCENARIO_CTRL_ENUM CtrlCode,
void* pParaIn, void* pParaOut,kal_uint16 ParaOutLen)
{
#ifdef FD_LOG_DEBUG_INFO
kal_uint32 t1,mem_time, total_fdvt_time, period_time;
#endif
kal_uint32 t0;
FD_PROCESS_IN_STRUCT FdProcIn ;
// P_FD_PROC_PARA_IN_STRUCT pFdParaIn = (P_FD_PROC_PARA_IN_STRUCT )pParaIn;
P_FD_RESULT_STRUCT pFdParaOut = &gFdResult;
UTL_SWITCH_CACHE_STRUCT MemSwitch;
UTL_BILINEAR_RESIZER_STRUCT UtlRisizerInfo;
ASSERT(gFdState!=FD_IDLE_STATE);
if(PP_CTRL_CODE_START == CtrlCode)
{
t0 = drv_get_current_time();
#ifdef FD_LOG_DEBUG_INFO
period_time = drv_get_duration_ms(gFdStartTime);
gFdStartTime = drv_get_current_time();
t1 = gFdStartTime;
#endif
/*-------------- MEM--------------*/
gFdState = FD_MEM_PROCESS_STATE;
#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
// copy source image form MDP to FD working memory
if(PP_MEM_OP_COPY_TO_PROC_BUF == gFdSetMemInfo.PpMemOpType)
{
kal_mem_cpy((kal_uint8*)(gFdSetMemInfo.PpProcBufAddr), (kal_uint8*)gFdSetMemInfo.PpSrcBufAddr, gFdSetMemInfo.PpSrcBufSize);
}
else if(PP_MEM_OP_RESIZE_TO_PROC_BUF== gFdSetMemInfo.PpMemOpType)
{
UtlRisizerInfo.srcAddr = (kal_uint16*) gFdSetMemInfo.PpSrcBufAddr;
UtlRisizerInfo.srcWidth= gSrcImageWidth;
UtlRisizerInfo.srcHeight= gSrcImageHeight;
UtlRisizerInfo.dstAddr = (kal_uint16*) gFdSetMemInfo.PpProcBufAddr;
UtlRisizerInfo.dstWidth = gDstImageWidth;
UtlRisizerInfo.dstHeight = gDstImageHeight;
UtlBilinearResizer(&UtlRisizerInfo);
}
else
{
return MM_ERROR_INVALID_PARAMETER;
}
#ifdef FD_LOG_DEBUG_INFO
mem_time = drv_get_duration_ms(t1);
t1 = drv_get_current_time();
#endif
/*-------------- FD --------------*/
gFdState = FD_PROCESS_STATE;
kal_mem_set(pFdParaOut, 0, sizeof(FD_RESULT_STRUCT));
FdProcIn.OperationMode= FD_FDVT_MODE;
FdCoreMain(&FdProcIn,pFdParaOut);
/* add fd processing counter for facial AF usage */
gFdProcessCounter++;
if(gFdProcessCounter>=255)
{
gFdProcessCounter=0;
}
pFdParaOut->result_counter = gFdProcessCounter;
pFdParaOut->fd_start_time= t0;
pFdParaOut->fd_end_time= drv_get_current_time();
//cached memory -> non-cachecd memory
MemSwitch.pMemAddr=&gFdSetMemInfo.PpProcBufAddr;
MemSwitch.Size=(kal_uint32) (FD_BUFFER_SIZE);
MemSwitch.CacheableFlag=KAL_FALSE;
UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL);
// cb to cal
pfPpFdCb(PP_CBID_FD_RESULT, pFdParaOut, sizeof(FD_RESULT_STRUCT));
/*-------------- Save Log --------------*/
#if (defined(FD_LOG_DEBUG_INFO))
total_fdvt_time = drv_get_duration_ms(t1);
gFdFileCount++;
FdCoreSaveLog(gFdLogBuff);
gFdLogBuff->version = FDVT_VERSION;
gFdLogBuff->frame_idx = gFdFileCount;
gFdLogBuff->mem_time = mem_time;
gFdLogBuff->total_fdvt_time = total_fdvt_time;
gFdLogBuff->fdvt_period_time = period_time;
if (gFdFileCount>gFdFileCountMax)
{
gFdFileCount = 0;
}
FdSaveLog(gFdFileCount);
#endif
gFdState = FD_READY_STATE;
}
else if (PP_CTRL_CODE_RESET == CtrlCode)
{
FdCoreReset();
}
return MM_ERROR_NONE;
} /* FdControl() */
