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; }