void video_renderer_task_req_hdlr(ilm_struct *ilm_msg)
{
#if defined(__MTK_TARGET__)
_video_renderer_task_local_param_t *local_para_ptr;
video_renderer_task_exec_func_t exec_func;
void * exec_param;
ASSERT(NULL != ilm_msg);
ASSERT(KAL_FALSE == kal_if_hisr());
ASSERT(KAL_FALSE == kal_if_lisr());
// get ilm parameters
local_para_ptr = (_video_renderer_task_local_param_t*) ilm_msg->local_para_ptr;
ASSERT(NULL != local_para_ptr);
exec_func = local_para_ptr->exec_func;
exec_param = &(local_para_ptr->exec_param);
// do execution
if (exec_func)
{
exec_func(exec_param);
}
#endif //#if defined(__MTK_TARGET__)
}
void L1Audio_ClearFlag( uint16 audio_id )
{
uint32 savedMask;
if (!kal_if_hisr() && !kal_if_lisr())
kal_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_CLEARFLAG_A,audio_id,l1audio.runningState);
else
kal_dev_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_CLEARFLAG_A,audio_id,l1audio.runningState);
kal_take_sem( l1audio.sema, KAL_INFINITE_WAIT );
ASSERT( l1audio.id_flag & (1 << audio_id) );
ASSERT( l1audio.runningState & (1 << audio_id) );
savedMask = SaveAndSetIRQMask();
l1audio.runningState &= ~(1 << audio_id);
RestoreIRQMask( savedMask );
if(l1audio.runningState == 0 ) {
SLEEP_UNLOCK();
}
if( (l1audio.runningState == 0) && (l1audio.disallowSleepState == 0) ) {
#if defined( __CENTRALIZED_SLEEP_MANAGER__ )
Audio_Wake_DSP(audio_id, KAL_FALSE);
#endif
}
kal_give_sem( l1audio.sema );
}
void idp_internal_crz_usel_dsel(kal_uint32 scenario, kal_uint32 source_w, kal_uint32 source_h, kal_uint32 target_w, kal_uint32 target_h, kal_uint32* usel, kal_uint32* dsel)
{
idp_custom_crz_usel_dsel(((CUSTOM_SCENARIO_ID)scenario), (source_w), (source_h), (target_w), (target_h), (usel), (dsel));
if ((INT_QueryExceptionStatus() == KAL_FALSE) && (kal_if_hisr() == KAL_FALSE) && (kal_if_lisr() == KAL_FALSE))
{
kal_trace(TRACE_INFO, IDP_CUSTOM_CRZ_U_D, (scenario), (source_w), (source_h), (target_w), (target_h), *(usel), *(dsel));
}
}
/*****************************************************************************
* FUNCTION
* aud_bt_a2dp_codec_callback
* DESCRIPTION
*
* PARAMETERS
* event [IN]
* param [?]
* RETURNS
* void
*****************************************************************************/
void aud_bt_a2dp_codec_callback(A2DP_Event event, void *param)
{
A2DP_codec_struct* codec_p = (A2DP_codec_struct*)param;
module_type src_mod_id;
if(kal_if_hisr() != KAL_FALSE)
src_mod_id = MOD_L1SPHISR;
else
src_mod_id = stack_get_active_module_id();
bt_a2dp_send_stream_data_send_req(src_mod_id, stream_handle, codec_p);
}
void drv_trace4(trace_class_enum trc_class, kal_uint32 msg_index, const char *arg_type, kal_uint32 data1, kal_uint32 data2, kal_uint32 data3, kal_uint32 data4)
{
if (INT_QueryExceptionStatus())
return;
if(kal_if_lisr() == KAL_TRUE)
return;
if(kal_if_hisr())
{
kal_dev_trace(trc_class, msg_index, arg_type, data1, data2, data3, data4);
}
else
{
kal_trace(trc_class, msg_index, arg_type, data1, data2, data3, data4);
}
}
/*****************************************************************************
* FUNCTION
* aud_send_ilm
* DESCRIPTION
* This function is used to send ilm.
* PARAMETERS
* dest_id [IN]
* msg_id [IN]
* local_param_ptr [?]
* peer_buf_ptr [?]
* RETURNS
* void
*****************************************************************************/
void aud_send_ilm(module_type dest_id, kal_uint16 msg_id, void *local_param_ptr, void *peer_buf_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
module_type src_id;
sap_type sap_id;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
/* Check destination module ID */
if (dest_id == MOD_NIL)
{
return;
}
/* Get source module ID */
if (kal_if_hisr())
{
// src_id = MOD_VISUAL_HISR;
return;
}
else
{
src_id = kal_get_active_module_id();
}
switch (dest_id)
{
case MOD_MED:
sap_id = MED_SAP;
break;
case MOD_UEM:
sap_id = MED_SAP;
break;
case MOD_NVRAM:
sap_id = PS_NVRAM_SAP;
break;
default:
sap_id = MED_SAP;
break;
}
msg_send6(src_id,dest_id,sap_id,msg_id,(local_para_struct*)local_param_ptr,(peer_buff_struct*)peer_buf_ptr);
}
void usbc_mode_switch(usb_mode_e mode){
kal_uint32 idx;
usbc_core_t* usbc_inst = usbc_core_get_instance();
usbc_class_reinit_func_t class_reinit;
usbc_ind_t ind_to_enqueue; // Do mode switch immediately if it is not in HISR, or enqueue a mode switch event for USBCORE task
if (!kal_if_hisr()) {
#if 1
if (mode == USB_MODE_MSD_OSDRTY){
/* wait 3 second for OSD known issue */
kal_sleep_task(600);
}
#endif
/* 1. set disconnect */
hifusb_set_disconnect();
usbc_empty_ind_queue();
/* 2. Set switch mode */
usbc_inst->is_mode_switch = KAL_TRUE;
usbc_inst->mode = mode;
/* 3. Send re-init callback to all usb class */
_SET_NODE_VALUE(0);
usbc_stack_checkin(USB_CLASS_NUM, NULL);
for (idx = 0; idx < USB_CLASS_NUM; idx++) {
class_reinit = _get_class_reinit_func(idx);
_SET_NODE_REG_TABLE(idx, NULL);
if (class_reinit) {
usbc_trace_info(USBCORE_ALL_NODE_CHECKIN_REINIT_CLASS_START, idx);
class_reinit(KAL_TRUE);
usbc_trace_info(USBCORE_ALL_NODE_CHECKIN_REINIT_CLASS_END, idx);
} else {
EXT_ASSERT(KAL_FALSE, 2, 0, 0);
}
}
} else {
ind_to_enqueue.type = USBC_IND_MODE_SWITCH;
ind_to_enqueue.ext = 0;
ind_to_enqueue.data = (kal_uint8)mode;
usbc_enqueue_ind(&ind_to_enqueue);
hmu_hifeg_set(HIF_DRV_EG_USBC_IND_EVENT);
}
}
void
idp_init(void)
{
kal_uint32 i;
/* All operations based on this buffer will assume that the size of the buffer
* is power of 2. This is to say that I have to ensure that the binary form of
* buffer_size must contain only one one.
*/
//ASSERT(1 == count_one_bit_number(IDP_TRACED_BUFFER_SIZE));
/* Because I need to call semaphore API, I have to ensure
* this function will not be called from HISR & LISR.
*/
if (kal_if_hisr() || kal_if_lisr())
{
ASSERT(0);
}
idp_owners_sem = kal_create_sem("IDP", 1);
for (i = 0; i < MAX_CONCURRENT_DP; ++i)
{
memset(&(owners[i]), 0, sizeof(owners[i]));
}
idp_hw_init();
#if defined(IDP_HISR_SUPPORT)
idp_hisr_init();
#endif
#if defined(DRV_IDP_6238_SERIES) || defined(DRV_IDP_MT6236_SERIES)
// For MT6268 VT video frame rotation
//idp_sw_yuv_rotator_init(); // for MT6268 VT
#endif // #if defined(DRV_IDP_6238_SERIES) || defined(DRV_IDP_MT6236_SERIES)
}
static void Audio_Wake_DSP(uint16 audio_id, kal_bool flag)
{
if (!kal_if_hisr() && !kal_if_lisr())
kal_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_MD2G_PWR_CTRL, audio_id, flag);
else
kal_dev_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_MD2G_PWR_CTRL, audio_id, flag);
if(flag)
{
#if defined(MT6260)
RM_Resource_Control (RM_MODEM_DSP_1, flag);
#else
Audio_SW_CPD_Event_Setting(flag);
Audio_SW_CPD_Eevent_ChangeMode(flag);
#endif
#if defined(MTK_SLEEP_ENABLE)
#if defined(__AUDIO_POWERON_RESET_DSP__)
{
extern void AFE_RegisterStore(void);
AFE_RegisterStore(); //restore AFE register
}
{
unsigned short DSP_status;
DSP_status = L1D_Audio_RestartDSP();
ASSERT(!DSP_status);
}
#else
L1SM_IntSleepDisable( l1audio.l1sm_handle );
L1SM_Multi_SW_WakeUp();
L1D_MD2G_PWD_Disable(l1audio.md2g_pdn_handle);
L1SM_IntSleepEnable( l1audio.l1sm_handle );
#endif
#endif
Audio_DSP_Wakeup_Eevent_Setting(flag);
l1audio.audio_cpd_count++;
l1audio.audio_cpd_count_current++;
} else {
Audio_DSP_Wakeup_Eevent_Setting(flag);
#if defined(MTK_SLEEP_ENABLE)
#if defined(__AUDIO_POWERON_RESET_DSP__)
L1D_Audio_NoNeedDSP();
AFE_RegisterBackup(); //Backup AFE register
#else
L1D_MD2G_PWD_Enable(l1audio.md2g_pdn_handle);
#endif
#endif
#if defined(MT6260)
RM_Resource_Control (RM_MODEM_DSP_1, flag);
#else
Audio_SW_CPD_Eevent_ChangeMode(flag);
#endif
l1audio.audio_cpd_count_current--;
#if __DSP_WAKEUP_EVENT__
Audio_DSP_Wakeup_Eevent_clean();
#endif
}
if (!kal_if_hisr() && !kal_if_lisr())
kal_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_MD2G_PWR_CTRL_DONE, audio_id, flag);
else
kal_dev_trace( TRACE_GROUP_AUD_MD2GCTRL, L1AUDIO_MD2G_PWR_CTRL_DONE, audio_id, flag);
}
HIF_RESULT hif_dma_read_internal(HIF_HANDLE handle, HIF_TYPE type, kal_uint32 addr, kal_uint32 size, HIF_CALLBACK fCB)
{
HIF_RESULT result = HIF_RESULT_OK;
HIF_INTERNAL_HANDLE_T* pHandle = (HIF_INTERNAL_HANDLE_T*) handle;
kal_uint32 retrieved_events;
// Enable HIF interrupt.
ENABLE_HIF_INTR(pHandle->engine_id);
pHandle->DMA_BUSY = KAL_TRUE;
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(hif_sleepMode_handle[pHandle->engine_id]);//unlock MD sleep mode
#endif
if (fCB == NULL)
{
if(!(kal_if_lisr()||kal_if_hisr()))
{
//Clear the evnet for pHandle->engine_id HIF for task level
kal_set_eg_events(hif_events, ~(1 << pHandle->engine_id), KAL_AND);
}
else
ASSERT(0); //HIF DMA blocking mode is not allowed in LISR or HISR
}
// Setup HIF.
//SET_HIF_BUS_WIDTH(pHandle->engine_id, pHandle->config.hif_bus_width);
SET_HIF_READ(pHandle->engine_id);
if(type == HIF_TYPE_A0H_DMA)
{
SET_HIF_A0_HIGH(pHandle->engine_id);
}
else if(type == HIF_TYPE_A0L_DMA)
{
SET_HIF_A0_LOW(pHandle->engine_id);
}
SET_HIF_DAMOUNT(pHandle->engine_id, size);
/* // Set DMA address.
PDMA_SET_BUF_ADDR(pHandle->engine_id, addr);
PDMA_SET_RW_DIRECTION(pHandle->engine_id, 1); // 1:read; 0: write
PDMA_SET_BUF_LEN(pHandle->engine_id, size);
PDMA_SET_BURST_LEN(pHandle->engine_id, 7);
PDMA_START(pHandle->engine_id); //Start DMA
*/
//dma config
SLA_CustomLogging("HDM",1);//set for debug
#if (defined(MT6752) && !defined(__ANDROID_MODEM__))
hif_dma_menu[pHandle->engine_id].addr = addr + 0x80000000;
#else
hif_dma_menu[pHandle->engine_id].addr = addr;
#endif
hif_dma_input[pHandle->engine_id].count = (pHandle->config.hif_bus_width == 16) ? (size >> 1) : size;
hif_dma_input[pHandle->engine_id].type = DMA_HWRX;
hif_dma_input[pHandle->engine_id].size = (pHandle->config.hif_bus_width == 16) ? DMA_SHORT : DMA_BYTE;
hif_dma_input[pHandle->engine_id].callback = NULL;
hif_dma_input[pHandle->engine_id].menu = (void*) &hif_dma_menu[pHandle->engine_id];
DMA_Config(hif_sysdma_id[pHandle->engine_id], &hif_dma_input[pHandle->engine_id], KAL_TRUE);
// Set fCB as HIF interrupt callback.
hif_cb[pHandle->engine_id] = fCB;
// Start HIF
START_HIF(pHandle->engine_id);
if (fCB == NULL)
{
if(!(kal_if_lisr()||kal_if_hisr()))
{
kal_retrieve_eg_events(hif_events, (1<<pHandle->engine_id), KAL_OR_CONSUME, &retrieved_events, KAL_SUSPEND);
pHandle->DMA_BUSY = KAL_FALSE;
}
else
ASSERT(0); //HIF DMA blocking mode is not allowed in LISR or HISR
}
return result;
}
kal_bool
idp_close(
kal_uint32 const key,
idp_close_hook_t const hook)
{
kal_bool result;
idp_owner_t *owner = NULL;
result = idp_find(key, &owner);
if (KAL_FALSE == result)
{
//ASSERT(0);
return KAL_FALSE;
}
result = hook(owner);
owner->key = 0;
/* Because I need to call semaphore API, I have to ensure
* this function will not be called from HISR & LISR.
*/
if (kal_if_hisr())
{
//ASSERT(0);
return KAL_FALSE;
}
if (kal_if_lisr())
{
//ASSERT(0);
return KAL_FALSE;
}
#if ((!defined(DRV_IDP_6252_SERIES)) && (!defined(DRV_IDP_6253_SERIES)))
// To see if there is no one use IDP.
{
kal_uint32 i;
kal_bool can_poweroff = KAL_TRUE;
// lock all possible data paths.
kal_take_sem(idp_owners_sem, KAL_INFINITE_WAIT);
for (i = 0; i < MAX_CONCURRENT_DP; ++i)
{
if (owners[i].key != 0)
{
// There at least one uses IDP now, so I can not
// power off IDP.
can_poweroff = KAL_FALSE;
}
}
if (KAL_TRUE == can_poweroff)
{
#if defined(IDP_DRVPDN_SUPPORT)
turn_off_idp_power();
#endif
}
// unlock all possible data paths.
kal_give_sem(idp_owners_sem);
}
#endif // ((!defined(DRV_IDP_6252_SERIES))...
return KAL_TRUE;
}
kal_bool
idp_find_empty_and_register(
kal_uint32 * const key,
idp_owner_t ** const owner)
{
kal_uint32 i;
kal_bool result = KAL_FALSE;
if (NULL == owner)
{
//ASSERT(0);
return KAL_FALSE;
}
/* Because I need to call semaphore API, I have to ensure
* this function will not be called from HISR & LISR.
*/
if (kal_if_hisr())
{
//ASSERT(0);
return KAL_FALSE;
}
if (kal_if_lisr())
{
//ASSERT(0);
return KAL_FALSE;
}
kal_take_sem(idp_owners_sem, KAL_INFINITE_WAIT);
for (i = 0; i < MAX_CONCURRENT_DP; ++i)
{
//kal_bool find_one = KAL_FALSE;
if (0 == owners[i].key)
{
kal_uint32 local_key;
while (1)
{
kal_bool cal_again = KAL_FALSE;
local_key = 0;
while (0 == local_key)
{
local_key = rand();
}
{
int j;
for (j = 0; j < MAX_CONCURRENT_DP; ++j)
{
if (j != i)
{
if (owners[j].key == local_key)
{
cal_again = KAL_TRUE;
}
if (KAL_TRUE == cal_again)
{
break;
}
}
}
}
if (KAL_FALSE == cal_again)
{
break;
}
}
owners[i].key = local_key;
(*key) = local_key;
owners[i].task = kal_get_current_thread_ID();
(*owner) = &(owners[i]);
result = KAL_TRUE;
//find_one = KAL_TRUE;
break;
}
//if (KAL_TRUE == find_one)
//{
// break;
//}
}
kal_give_sem(idp_owners_sem);
return result;
}
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;
}
