void DSP_BGSND_Shared_Hisr_DL_UL(void * param) { kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_Shared_Hisr_DL_UL] Enter"); DSP_BGSND_Hisr(BGSND_UL_PROCESS); DSP_BGSND_Hisr(BGSND_DL_PROCESS); kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_Shared_Hisr_DL_UL] Leave"); }
static void DSP_BGSND_INIT() { kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_INIT] Enter"); memset(&DSP_BGSnd, 0, sizeof(DSP_BKGSND_T)); //has_ul = has_dl = 0; kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_INIT] Leave"); }
/*static*/ int32 EXT_BGSND_GetDataCount(uint32 id, BGSND_PROCESS_TYPE type) { int32 count = 0; kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_GetDataCount] Enter"); ASSERT( type == BGSND_DL_PROCESS || type == BGSND_UL_PROCESS ); EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; count = (pSrc->bufSize[type] - EXT_BGSND_BUF_PTR_DIFF) - EXT_BGSND_GetFreeSpace(id, type); /* for(j=0; j<MAX_BGSND_BUFFER_PROCESS_BIT; j++){ if(type & (1<<j)){ type = 1<<j; if(pSrc->bufWrite[type]<pSrc->bufRead[type]){ count = (pSrc->bufSize[type] - EXT_BGSND_BUF_PTR_DIFF)+pSrc->bufWrite[type] - pSrc->bufRead[type]; } else { count = pSrc->bufWrite[type] - pSrc->bufRead[type]; } } } if( count > EXT_BGSND_BUF_PTR_DIFF) { count -= EXT_BGSND_BUF_PTR_DIFF; } else { count = 0; } if(count&1){ count = count -1; }*/ kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_GetDataCount] count=%d", count); kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_GetDataCount] Leave"); return count; }
void DSP_BGSND_Stop(void) { kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_Stop] Enter"); DSP_BGSnd.state = DSP_BGSND_STATE_STOPPING; { //turn off DSP BGSND uint32 I; if(SAL_Bgsnd_IsRunning()) SAL_Bgsnd_SetFinal(); for ( I = 0; ; I++ ) { if ( SAL_Bgsnd_IsIdle()) /* DSP returns to idle state */ break; ASSERT_REBOOT( I < 20 ); kal_sleep_task( 2 ); } AM_SND_PlaybackOff( true ); } #ifdef DSP_BGS_UP_DOWN_INT_SEPERATE L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL); L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_UL); #else L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL); #endif DSP_BGSnd.state = DSP_BGSND_STATE_IDLE; kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_Stop] Leave"); }
/***************************************************************************** * FUNCTION * tp_ps_handling_at_indication * DESCRIPTION * This function is used to handle the response/URC data from MOD_ATCI * * PARAMETERS * channelId [IN] * buf [IN] * iDataLen [IN] * * RETURNS * void *****************************************************************************/ static void tp_ps_handling_at_indication(kal_uint8 channelId, kal_char *buf, kal_uint16 iDataLen) { kal_char *data; if (tp_callback == NULL || tp_port_begin == -1) { if (tp_callback == NULL) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] ERROR: havn't register TP callback function"); } else if (tp_port_begin == -1) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] ERROR: havn't start PS, please call tp_ps_start first"); } // buffer the URC if (channelId == RMMI_MSG_BASED_URC_CHANNEL) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] Buffer the URC: %s", buf); if ( (tp_urc_buffer_len + iDataLen) > MAX_TP_URC_BUFFER_LENGTH) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] URC buffer is full, clean the buffer", buf); tp_urc_buffer_len = 0; } if (iDataLen > MAX_TP_URC_BUFFER_LENGTH) { kal_prompt_trace( stack_get_active_module_id(), "[Hdlr] ERROR: the URC is too large, please increase the URC buffer"); } else { kal_mem_cpy(tp_urc_buffer+tp_urc_buffer_len, buf, iDataLen); tp_urc_buffer_len += iDataLen; } } } else { data = get_ctrl_buffer(iDataLen); kal_mem_cpy(data, buf, iDataLen); tp_callback(channelId, data, iDataLen, 1); free_ctrl_buffer(data); } }
/***************************************************************************** * FUNCTION *matv_module_power_on * DESCRIPTION * config power on seq * PARAMETERS * RETURNS * NONE *****************************************************************************/ void matv_module_power_on(void) { if(is_factory_boot()) { kal_prompt_trace(MOD_MATV, "Factory Mode\n"); } else { kal_prompt_trace(MOD_MATV, "Normal Mode\n"); } // DrvSetChipDep(MTK_TVD_CamIFMode,0); DrvSetChipDep(MTK_TVD_CamIFMode,1);//for serial DrvSetChipDep(MTK_PAD_DRIVING,0x0f);//for serial 0: Data 0x09 : 9ma F:12ma DrvSetChipDep(MTK_PAD_DRIVING,0xAf);//for serial A: clk 0x09 DrvSetChipDep(MTK_TVD_CamIFRefMCLK,0); #if CUSTOM_AVC_ON DrvSetChipDep(MTK_AUD_AVC,0x30000); #else DrvSetChipDep(MTK_AUD_AVC,0x0); #endif #if 0 ///ifdef CAMERA_IO_DRV_1800 DrvSetChipDep(MTK_PAD_DRIVING,0x02); DrvSetChipDep(MTK_PAD_DRIVING,0x12); DrvSetChipDep(MTK_PAD_DRIVING,0x22); DrvSetChipDep(MTK_PAD_DRIVING,0x32); DrvSetChipDep(MTK_PAD_DRIVING,0x42); DrvSetChipDep(MTK_PAD_DRIVING,0x52); DrvSetChipDep(MTK_PAD_DRIVING,0x62); DrvSetChipDep(MTK_PAD_DRIVING,0x72); DrvSetChipDep(MTK_PAD_DRIVING,0x82); DrvSetChipDep(MTK_PAD_DRIVING,0x92); DrvSetChipDep(MTK_PAD_DRIVING,0xa2); DrvSetChipDep(MTK_PAD_DRIVING,0xb2); #else kal_prompt_trace(MOD_MATV, "Factory Mode max\n"); ///0x08 --> 0xb8 DrvSetChipDep(MTK_PAD_DRIVING,0x0f); DrvSetChipDep(MTK_PAD_DRIVING,0x1f); DrvSetChipDep(MTK_PAD_DRIVING,0x2f); DrvSetChipDep(MTK_PAD_DRIVING,0x3f); DrvSetChipDep(MTK_PAD_DRIVING,0x4f); DrvSetChipDep(MTK_PAD_DRIVING,0x5f); DrvSetChipDep(MTK_PAD_DRIVING,0x6f); DrvSetChipDep(MTK_PAD_DRIVING,0x7f); DrvSetChipDep(MTK_PAD_DRIVING,0x8f); DrvSetChipDep(MTK_PAD_DRIVING,0x9f); DrvSetChipDep(MTK_PAD_DRIVING,0xaf); DrvSetChipDep(MTK_PAD_DRIVING,0xbf); #endif }
uint32 EXT_BGSND_init() { kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_init] Enter"); DSP_BGSND_INIT(); memset((void *)&Ext_BGSnd, 0, sizeof(EXT_BGSND_T)); // get audio ID Ext_BGSnd.aud_id = L1Audio_GetAudioID(); kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_init] Leave"); // L1Audio_SetEventHandler( Ext_BGSnd.aud_id, (L1Audio_EventHandler) EXT_BGSND_EventHandler ); }
//from DL Src buffer -> DL ext buffer, multiplied by gain //from UL Src buffer -> UL ext buffer void EXT_BGSND_WriteExtBuffer(uint32 id, int gain, BGSND_PROCESS_TYPE type) // ToDo { volatile uint16 *toPtr; int32 count, segment, i; uint16 *dataPtr; uint16 gainFactor; kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] Enter "); kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] selected_src_id = %d BGSND_PROCESS_TYPE(0->DL, 1->UL)=%d", id, type); ASSERT( type == BGSND_DL_PROCESS || type == BGSND_UL_PROCESS ); EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[id]; kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] fSph=%d gain=%d ", pSrc->fSph[type], pSrc->gain[type]); gainFactor = pSrc->gain[type]; count = EXT_BGSND_GetDataCount(id, type); toPtr = Ext_BGSnd.buffer[type]; kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] count=%d ", count); if (count > BGSND_BUFFER_LEN_WB) count = BGSND_BUFFER_LEN_WB; if(count > 0) { /* First Segemnt */ if(pSrc->bufWrite[type] < pSrc->bufRead[type]) { segment = (pSrc->bufSize[type] - pSrc->bufRead[type]); } else { segment = (pSrc->bufWrite[type] - pSrc->bufRead[type]); } if(segment&1){ // keep two sample alight segment =segment - 1; } if (segment > count) segment = count; if (segment > 0) { dataPtr = &(pSrc->buffer[type][pSrc->bufRead[type]]); if(pSrc->fSph[type] && MAX_LEVEL_EXT_BGSND_GAIN!=gainFactor){ for (i=0; i<segment; i++) { if( *dataPtr < (0x1111111111111111 - *toPtr)){ //limiter *toPtr += ((*dataPtr)>>gainFactor); }else{ kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_WriteExtBuffer] overflows1"); ASSERT(0); } toPtr++; dataPtr++; } pSrc->dspLastSample[type] = *(toPtr-1); }else{
static void DSP_BGSND_UpdateMixer() // private { kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_UpdateMixer] Enter"); if ( AM_IsSpeechOn() || AM_IsVoIPOn()) { SAL_Bgsnd_Config(DSP_BGSnd.gain[BGSND_UL_PROCESS], DSP_BGSnd.gain[BGSND_DL_PROCESS], DSP_BGSnd.fSph[BGSND_UL_PROCESS], DSP_BGSnd.fSph[BGSND_DL_PROCESS]); } else { //When enable BT, spe_setSpeechMode() will do Speech Off and Speech On. This function may run between Off and ON, so do not use ASSERT(). //ASSERT(false); SAL_Bgsnd_Config(DSP_BGSnd.gain[BGSND_UL_PROCESS], DSP_BGSnd.gain[BGSND_DL_PROCESS], 0, 0); } kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_UpdateMixer] Leave"); }
/* * Function * custom_cfg_vbat_level_regulator * DESCRIPTION * The function is used to convert the vbat value to the end-user level . * And it will be call by audio manager. * PARAMETERS * vbat IN * RETURNS * kal_uint8 * GLOBALS AFFECTED */ kal_uint8 custom_cfg_vbat_level_regulator( kal_uint32 measure_voltage, kal_uint8 *last_level, kal_uint8 *disp_level, kal_uint8 *hit_count ) { kal_uint8 level=0; kal_uint8 regulated_level=0; for( level=0; level<BATTERY_MAX_LEVEL; level++) if( measure_voltage <= Battery_Level_Info[level] ) break; kal_prompt_trace(MOD_UEM, "Begin: [level %d] [last %d] [disp %d] [hit %d]", \ level, *last_level, *disp_level, *hit_count ); if( level > *disp_level ) { for( level=0; level<BATTERY_MAX_LEVEL; level++) if( measure_voltage <= (Battery_Level_Info[level] + VBAT_GROWUP_PENALTY) ) break; } kal_prompt_trace(MOD_UEM, "Penalty: [level %d] [last %d] [disp %d] [hit %d]", \ level, *last_level, *disp_level, *hit_count ); if( level == *last_level ) { if( *hit_count >= VBAT_HIT_COUNT_BOUND ) { regulated_level = *disp_level = level; } else { (*hit_count)++; regulated_level = *disp_level; } } else { *hit_count=1; regulated_level = *disp_level; } kal_prompt_trace(MOD_UEM, "End: [level %d] [last %d] [disp %d] [hit %d]", \ level, *last_level, *disp_level, *hit_count ); *last_level = level; if( level <= BATTERY_LOW_WARNING ) return ( level ); else return ( *disp_level ); }
void avb_HisrHandler(void *data) { uint16 ptr_addr; int16 *dspPtr; uint32 outputNum,i; if (AVB.enable == false) return; if( DSP_TONE_CTRL2 != 0 || DSP_TONE_CTRL1 != 0 ){ AVB.downsampler->GetSamples( AVB.downsampler, NULL, 160, false, true ); kal_prompt_trace( MOD_L1SPHISR, "KT1=%x,KT2=%x",DSP_TONE_CTRL1,DSP_TONE_CTRL2); } else { ptr_addr = *DSP_DM_ADDR(BT_AUDIO_PLAYBACK_SD_PAGE_NUM, BT_AUDIO_PLAYBACK_SD_PTR_ADDR); ASSERT( ptr_addr >= BT_AUDIO_PLAYBACK_SD_ADDR && ptr_addr < (BT_AUDIO_PLAYBACK_SD_ADDR + BT_AUDIO_PLAYBACK_SD_BUF_LEN) ); dspPtr = (int16 *)DSP_DM_ADDR(BT_AUDIO_PLAYBACK_SD_PAGE_NUM, ptr_addr); outputNum = AVB.downsampler->GetOutputNum(AVB.downsampler); kal_prompt_trace( MOD_L1SPHISR, "AVB outNum =%d,Put2DSPAddr=%x", outputNum, ptr_addr); if ( AVB.buffered < 3 && outputNum >= 1024 ){ // avoid initial discontinuity AVB.buffered++; } if( outputNum > 160 && AVB.buffered > 2 ) AVB.downsampler->GetSamples( AVB.downsampler, dspPtr, 160, false, false ); else if ( AVB.flushing ){ if (outputNum >= 160){ AVB.downsampler->GetSamples( AVB.downsampler, dspPtr, 160, false, false ); kal_prompt_trace( MOD_L1SPHISR, "AVB Flushing"); } else{ AVB.downsampler->GetSamples( AVB.downsampler, dspPtr, outputNum, false, false ); dspPtr += outputNum; for( i = outputNum ; i < 160 ; i++ ) *dspPtr++ = 0; kal_prompt_trace( MOD_L1SPHISR, "AVB Flushed"); } } else { for( i = 160 ; i > 0 ; i-- ) *dspPtr++ = 0; kal_prompt_trace( MOD_L1SPHISR, "AVB fill Silence,outBuf=%d",outputNum); } //get other samples to DSP via DSP //dspPtr = (int16 *)IDMA_SHORT_ADDR; //AVB.downsampler->GetSamples(AVB.downsampler, dspPtr, 159, true, false); } }
static void DSP_BGSND_ConfigMixer(kal_bool bSPHFlag, kal_int8 SNDGain, BGSND_PROCESS_TYPE type) { kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_ConfigMixer] Enter"); kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_ConfigMixer] BGSND_PROCESS_TYPE(0->DL, 1->UL)=%d flag:%d, gain:%d", type, bSPHFlag, SNDGain); ASSERT(SNDGain>=0 && SNDGain<=7); if( SNDGain == 0) DSP_BGSnd.gain[type] = 0; else { DSP_BGSnd.gain[type] = (kal_int16)(32767 >> (7 - SNDGain)); } DSP_BGSnd.fSph[type] = bSPHFlag; kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_ConfigMixer] Leave"); }
uint32 EXT_BGSND_Start(void (*offHdr)(void), void (*DLHisr)(void), //move data from src -> ext void (*ULHisr)(void), //move data from src -> ext kal_int8 DLSNDGain, kal_int8 ULSNDGain /*, void (*EventHandler)(void)*/) { int i, j; kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] Enter"); ASSERT(!(NULL==DLHisr && NULL==ULHisr)); ASSERT(NULL!=offHdr); //without this, we cannot stop DSP BGSND for(i=0; i<MAX_SIZE_EXT_BGSND_SRC; i++){ kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] debug1 i=%d", i); if(!Ext_BGSnd.is_used[i]){ kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] debug2 i=%d", i); EXT_BGSND_SRC_T *pSrc = &Ext_BGSnd.src[i]; pSrc->Hdr[BGSND_DL_PROCESS] = DLHisr; pSrc->Hdr[BGSND_UL_PROCESS] = ULHisr; pSrc->offHdr = offHdr; for(j=0; j<MAX_NUM_BGSND_PROCESS; j++){//TODO temp solution pSrc->state[j] = EXT_SRC_STATE_RUN; //pSrc->fSph[j] = true; //TODO //pSrc->gain[j] = 7; //TODO // buffer reset memset(pSrc->buffer[j], 0, sizeof(kal_uint16)*EXT_BGSND_SRC_BUF_SIZE); pSrc->bufSize[j] = EXT_BGSND_SRC_BUF_SIZE; pSrc->bufRead[j] = 0; pSrc->bufWrite[j] = EXT_BGSND_BUF_PTR_DIFF; } if(AM_IsSpeechOn() || AM_IsVoIPOn()){ EXT_BGSND_ConfigMixer(i, true, DLSNDGain, BGSND_DL_PROCESS); EXT_BGSND_ConfigMixer(i, true, ULSNDGain, BGSND_UL_PROCESS); }else{ EXT_BGSND_ConfigMixer(i, false, DLSNDGain, BGSND_DL_PROCESS); EXT_BGSND_ConfigMixer(i, false, ULSNDGain, BGSND_UL_PROCESS); } Ext_BGSnd.is_used[i] = true; if( 0 == Ext_BGSnd.num_src_used++){ kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] selected_src_id=%d num_src_used=%d", i, Ext_BGSnd.num_src_used); // lock DSP for sherif writing. L1Audio_SetFlag( Ext_BGSnd.aud_id ); // REIMIND: Before Locking SleepMode, to access DSP sherrif tasks much time. So access DSP must be after SetFlag1 DSP_BGSND_Start(EXT_BGSND_DLHisr, EXT_BGSND_ULHisr); } kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] debug3 i=%d", i); break; } kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] debug4 i=%d", i); } kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] debug5 i=%d", i); ASSERT(i < MAX_SIZE_EXT_BGSND_SRC); kal_prompt_trace(MOD_L1SP, "[EXT_BGSND_Start] Leave"); return i; }
/* * FUNCTION * acc_sensor_pwr_up * * DESCRIPTION * This function is to power up acceleration module * * CALLS * * PARAMETERS * None * * RETURNS * None */ void acc_sensor_pwr_up(void) { kal_int32 i; kal_prompt_trace(MOD_ENG,"----acc_sensor_pwr_up start----"); motion_sensor_write_data(0x80, MOTION_SENSOR_CTRL_REGC);//ktxf9 reset MS_Delay(30000);//delay for ktxf9 reset motion_sensor_write_data(0x00, MOTION_SENSOR_CTRL_REGA); motion_sensor_write_data(0x50, MOTION_SENSOR_CTRL_REGA);//set to 12 bit 8g motion_sensor_write_data(0x00, MOTION_SENSOR_CTRL_REGB); motion_sensor_write_data(0xd0, MOTION_SENSOR_CTRL_REGA);//set to work mode motion_sensor_write_data(0x00,MOTION_SENSOR_INT_CTRL_REG1);//disable all interrupt funs motion_sensor_write_data(0x00,MOTION_SENSOR_INT_CTRL_REG2); motion_sensor_write_data(0x00,MOTION_SENSOR_INT_CTRL_REG3); kal_prompt_trace(MOD_ENG,"----acc_sensor_pwr_up end----"); }
/***************************************************************************** * FUNCTION * mmi_fm_fm_ate_test_cmd_req_hdlr * DESCRIPTION * Test cammand req handler, this function will handle test requst send from * L4 Uart (at+cmd) * PARAMETERS * msg_ptr [IN] message data * RETURNS * void *****************************************************************************/ void fm_ate_test_cmd_req_hdlr(void *msg_ptr) { mmi_fm_ate_test_req_struct *ind_p; kal_uint8 buffer[10]; ind_p = (mmi_fm_ate_test_req_struct*)msg_ptr; if (ind_p->event == MMI_FM_ATE_EVENT_POWER_ON) { fm_ate_power_on(); fm_ate_set_freq(FM_ATE_DEFAULT_FREQ); } else if (ind_p->event == MMI_FM_ATE_EVENT_POWER_OFF) { fm_ate_power_off(); } else if (ind_p->event == MMI_FM_ATE_EVENT_SET_FREQ) { fm_ate_set_freq((ind_p->cmd_buf[0]<<8)+ind_p->cmd_buf[1]); } else if (ind_p->event == MMI_FM_ATE_EVENT_COMMAND) { fm_ate_other_command(ind_p->cmd_length, ind_p->cmd_buf); } else { //MDI_ASSERT(0); kal_prompt_trace(MOD_FMR,"fm_ate_test_cmd_req_hdlr: unknow command!"); kal_sprintf((kal_char*) buffer, "FM:FAIL"); // now buffer string is "REG=12" rmmi_write_to_uart(buffer, strlen((char*)buffer),KAL_TRUE); } }
S32 CALLCC VideoRecordService::gs_video_rec_record_stop() { S32 ret; ret = mdi_video_rec_record_stop(); kal_prompt_trace(MOD_IDLE,"mdi_video_rec_record_stop ret = %d",ret); return ret; }
S32 CALLCC VideoRecordService::gs_video_rec_power_on() { S32 ret = mdi_video_rec_power_on(ASM_ANONYMOUS_ID); kal_prompt_trace(MOD_IDLE,"mdi_video_rec_power_on ret = %d",ret); return ret; }
S32 CALLCC VideoRecordService::gs_video_rec_record_pause(MMI_BOOL stop_preview) { S32 ret; ret = mdi_video_rec_record_pause( stop_preview); kal_prompt_trace(MOD_IDLE,"mdi_video_rec_record_pause ret = %d",ret); return ret; }
kal_bool fm_scan(struct fm_scan_parm *parm){ kal_bool return_value; kal_prompt_trace(MOD_MATV, "[FM] fm_scan In"); if (NULL != matv_sem_id) kal_take_sem(matv_sem_id, KAL_INFINITE_WAIT); return_value=fmdrv_scan(parm); if (NULL != matv_sem_id) kal_give_sem(matv_sem_id); kal_prompt_trace(MOD_MATV, "[FM] fm_scan Out"); return return_value; }
void MTPNP_PFAL_Shutdown_Timeout(void) { kal_prompt_trace(MTPNP_PFAL_Get_MTPNP_Task_Mod(), "MTPNP_PFAL_Shutdown_Timeout"); MTPNP_PFAL_Stop_Timer(MTPNP_RELEASE_SLAVE_PWRKEY_TIMER); MTPNP_PFAL_Start_Timer(SYSTEM_SHUTDOWN, POWER_OFF_TIMER_STAGE_2, QuitSystemOperation); }
S32 CALLCC VideoRecordService::gs_video_set_camera_id(U16 camera_id) { S32 ret = mdi_video_set_camera_id(camera_id); kal_prompt_trace(MOD_IDLE,"mdi_video_set_camera_id ret = %d",ret); return ret; }
void SP_Strm_Enable( ilm_struct *ilm_ptr ) { UART_CTRL_OPEN_T data; DCL_STATUS status; cmux_dlc_connect_ind_struct *local_para; if (intSStrmControl != NULL ) return; local_para = (cmux_dlc_connect_ind_struct *)ilm_ptr->local_para_ptr; if( ss_enh_mutex == NULL) // no delete mutex ss_enh_mutex = kal_create_enh_mutex( "SP_STRM_ENH_MUTEX" ); intSStrmControl = (SpStrmControl *)get_ctrl_buffer(sizeof(SpStrmControl)); intSStrmControl->ul_ready = KAL_FALSE; intSStrmControl->ul_sample_count = 0; intSStrmControl->port = local_para->port; kal_prompt_trace(MOD_L1SP, "SS port %d", intSStrmControl->port); #if !defined(SS_UNIT_TEST) data.u4OwenrId = MOD_MED; intSStrmControl->cmux_handle = DclSerialPort_Open(intSStrmControl->port, 0); status = DclSerialPort_Control(intSStrmControl->cmux_handle, SIO_CMD_OPEN, (DCL_CTRL_DATA_T*)&data); ASSERT(STATUS_OK == status); #endif L1SP_Register_Strm_Handler( spStrmOnHandler, spStrmOffHandler, spStrmCallback ); }
void RDABT_core_Intialization_r10_al(void) { kal_prompt_trace(0,"RDABT_core_Intialization_r10_al"); RDA_bt_Power_On_Reset(); RDABT_DELAY(10); //wait for digi running #ifdef __RDABT_USE_IIC__ RDABT_rf_Intialization_r10_al(); #else RDABT_uart_rf_Intialization_r10_al(); #endif Rdabt_Pskey_Write_rf_r10_al(); RDABT_DELAY(5); //wait for digi running #ifdef __RDABT_USE_IIC__ rdabt_DC_write_r10_al(); #else rdabt_uart_DC_write_r10_al(); #endif Rdabt_Pskey_Write_r10(); Rdabt_unsniff_prerxon_write_r10(); Rdabt_patch_write_r10(); Rdabt_setfilter_r10(); Rdabt_acl_patch_write_r10(); Rdabt_trap_write_r10(); #ifdef __RDA_USE_LPO_32K__ Rdabt_lpo_Setting__write_r10_al(); Rdabt_lpo_patch_write_r10_al(); #endif }
//If controller has the register store these informations //Read out the informations from controller through I2C void ctp_cypress_cy8ctma340_get_information() { kal_uint8 value[4]; kal_bool i2c_ret; i2c_ret = CTP_I2C_read(CID_0, value, 3); kal_prompt_trace(MOD_TP_TASK, "ctp_cypress_cy8ctma340_get_information i2c_ret=%d CID_0=%x CID_1=%x CID_2=%x", i2c_ret, value[0], value[1], value[2]); i2c_ret = CTP_I2C_read(UID_0, value, 4); kal_prompt_trace(MOD_TP_TASK, "ctp_cypress_cy8ctma340_get_information i2c_ret=%d UID_0=%x UID_1=%x UID_2=%x UID_3=%x", i2c_ret, value[0], value[1], value[2], value[3]); i2c_ret = CTP_I2C_read(UID_4, value, 4); kal_prompt_trace(MOD_TP_TASK, "ctp_cypress_cy8ctma340_get_information i2c_ret=%d UID_4=%x UID_5=%x UID_6=%x UID_7=%x", i2c_ret, value[0], value[1], value[2], value[3]); i2c_ret = CTP_I2C_read(BL_VERH, value, 4); kal_prompt_trace(MOD_TP_TASK, "ctp_cypress_cy8ctma340_get_information i2c_ret=%d BL_VERH=%x BL_VERL=%x TTS_VERH=%x TTS_VERL=%x", i2c_ret, value[0], value[1], value[2], value[3]); i2c_ret = CTP_I2C_read(APP_IDH, value, 4); kal_prompt_trace(MOD_TP_TASK, "ctp_cypress_cy8ctma340_get_information i2c_ret=%d APP_IDH=%x APP_IDL=%x APP_VERH=%x APP_VERL=%x", i2c_ret, value[0], value[1], value[2], value[3]); }
void bt_discovery_result_ind_cb(t_MGR_DeviceEntry *newDevice, int status) { kal_prompt_trace(1,"bt_discovery_result_ind_cb find device ? newDevice =%x,status =%d ", newDevice,status); if(!newDevice) { LINK_DISCOVERY_CNF_ST mv; mv.type = LINK_DISCOVERY_CNF; mv.result = status; mv.total_number = MGR_GetDeviceNumFound(); rdabt_put_message(EXTERNAL_TASK_MASK,LINK_Q,&mv); } else { if(status == 0) { LINK_DISCOVERY_RESULT_ST mv; mv.type = LINK_DISCOVERY_RESULT_IND; mv.result = status; //pMemcpy(mv.device.address.bytes, (u_int8 *)&newDevice, sizeof(t_MGR_DeviceEntry)); mv.device = (t_MGR_DeviceEntry *)newDevice; rdabt_put_message(EXTERNAL_TASK_MASK,LINK_Q,&mv); } } }
static int is_factory_boot(void) { int fd; size_t s; char boot_mode; fd = open("/sys/class/BOOT/BOOT/boot/boot_mode", O_RDWR); if (fd < 0) { kal_prompt_trace(MOD_MATV, "fail to open: %s\n", "/sys/class/BOOT/BOOT/boot/boot_mode"); return 0; } s = read(fd, (void *)&boot_mode, sizeof(boot_mode)); close(fd); if (s <= 0 || boot_mode != '4') return 0; kal_prompt_trace(MOD_MATV, "Factory Mode Booting.....\n"); return 1; }
/***************************************************************************** * FUNCTION *matv_fm_module_power_on * DESCRIPTION * config power on seq * PARAMETERS * RETURNS * NONE *****************************************************************************/ void matv_fm_module_power_on(void) { if(is_factory_boot()) { kal_prompt_trace(MOD_MATV, "Factory Mode\n"); } else { kal_prompt_trace(MOD_MATV, "Normal Mode\n"); } #if CUSTOM_AVC_ON DrvSetChipDep(MTK_AUD_AVC,0x30000); #else DrvSetChipDep(MTK_AUD_AVC,0x0); #endif }
/***************************************************************************** * FUNCTION * mmi_fm_fm_ate_power_on * DESCRIPTION * Power on FM module * PARAMETERS * void * RETURNS * void *****************************************************************************/ void fm_ate_power_on(void) { if (FMR_IsActive() == KAL_FALSE) { mdi_fmr_power_on_with_path(MDI_DEVICE_SPEAKER2, (mdi_ext_callback) NULL,NULL); kal_prompt_trace(MOD_FMR,"fm_atcommand_power_on: DONE!"); } }
static void mmi_em_misc_rf_desense_mode_min_emi_current(void) { rf_desense_set_curr_mode(RF_DESENSE_MODE_MIN_EMI_CURRENT); //#if defined(MT6256) EMI_SetMinDrivingCurrent(); kal_prompt_trace(MOD_MED, "[RF Desense] [Minimum EMI driving current] Pass!\n"); //custom_DynamicClockSwitch(SSC_IDLE); //#endif }
/***************************************************************************** * FUNCTION * mmi_fm_fm_ate_power_off * DESCRIPTION * Power off FM module * PARAMETERS * void * RETURNS * void *****************************************************************************/ void fm_ate_power_off(void) { if (FMR_IsActive() == KAL_TRUE) { mdi_fmr_power_off(); kal_prompt_trace(MOD_FMR,"fm_atcommand_power_off: DONE!"); } }