/*
* FUNCTION
* ADC_GetMeaData
*
* DESCRIPTION
* This function is to run ADC, and obtain the average value of measured data
* Note that: This function only called before other tasks are running.
*
* CALLS
*
* PARAMETERS
* sel : selection of input signal source(0-4)
* meacount: measure count
*
* RETURNS
* return the average value of ADC output
*
* GLOBALS AFFECTED
* None
*/
kal_uint32 ADC_GetMeaData(kal_uint8 sel, kal_uint16 meacount)
{
#if defined(DRV_ADC_NOT_EXIST)
return 0;
#endif // #if defined(DRV_ADC_NOT_EXIST)
#ifndef DRV_ADC_NOT_EXIST
kal_uint32 index;
kal_uint32 sum=0;
#ifdef __MULTI_BOOT__
ASSERT(kal_query_boot_mode() == FACTORY_BOOT);
#endif /*__MULTI_BOOT__*/
//DRVPDN_Disable(DRVPDN_CON2,DRVPDN_CON2_AUXADC,PDN_ADC);
//adc_pwrdown_disable();
for(index=meacount;index!=0;index--)
{
sum += (kal_uint32)ADC_GetData(sel);
}
//DRVPDN_Enable(DRVPDN_CON2,DRVPDN_CON2_AUXADC,PDN_ADC);
//adc_pwrdown_enable();
sum = sum/meacount;
return sum;
#endif // #ifndef DRV_ADC_NOT_EXIST
}
kal_bool SIM_ATP_functional_test(kal_uint32 SIM_index)
{
sprintf(simtest,"=>SIM_ATP_functional_test:%d , mode:%d",SIM_index,kal_query_boot_mode());
//kal_print(simtest);
simfactorytest=KAL_TRUE;
{
DCL_CTRL_DATA_T reset_data;
DCL_SIM_POWER ResultVolt_ptr;
reset_data.rSIMRst.ExpectVolt = DCL_CLASS_C_18V;
reset_data.rSIMRst.ResultVolt = &ResultVolt_ptr;
reset_data.rSIMRst.warm = KAL_FALSE;
reset_data.rSIMRst.rstResult = DCL_USIM_NO_ERROR;
if(0 == simFunctionalTestHandle[SIM_index])
{
DCL_CONFIGURE_T configure;
simFunctionalTestHandle[SIM_index] = DclSIM_Open(DCL_SIM, 0);
configure.rSimConfig.apType = SIM_index | LOCAL_MODE_MAGIC; //SIM_index start from 0, SIM_ICC_APPLICATION_PHONE1 also start from 0
DclSIM_Configure(simFunctionalTestHandle[SIM_index], &configure);
}
DclSIM_Control(simFunctionalTestHandle[SIM_index], SIM_CTRL_CMD_RST, &reset_data);
if(DCL_USIM_NO_ERROR == reset_data.rSIMRst.rstResult)
{
sprintf(simtest,"=>SIM_ATP_functional_test:%d , success",SIM_index);
//kal_print(simtest);
return 1;
}
else
{
sprintf(simtest,"=>SIM_ATP_functional_test:%d , fail",SIM_index);
//kal_print(simtest);
return 0;
//return 1000+reset_data.rSIMRst.rstResult;
}
}
}
/*****************************************************************************
* FUNCTION
* nvram_reset_handler
* DESCRIPTION
* This is nvram_reset_handler() function of NVRAM module.
* PARAMETERS
* ilm_ptr [IN] The primitives
* RETURNS
* void
*****************************************************************************/
void nvram_reset_handler(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
nvram_ltable_entry_struct *ldi;
nvram_reset_req_struct *nvram_reset_req = (nvram_reset_req_struct*) ilm_ptr->local_para_ptr;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
nvram_trace(TRACE_FUNC, FUNC_NVRAM_RESET);
ASSERT(nvram_reset_req != NULL);
if (nvram_ptr->dev_broken)
{
nvram_reset_confirm(ilm_ptr->src_mod_id, NVRAM_ERRNO_SUCCESS, nvram_reset_req);
}
else
{
if (nvram_ptr->state == NVRAM_STATE_READY)
{
if (!(nvram_reset_req->reset_category & NVRAM_RESET_CERTAIN))
{
nvram_reset_req->LID = 0;
}
nvram_util_get_data_item(&ldi, nvram_reset_req->LID);
if (nvram_reset_req->reset_category == NVRAM_RESET_CERTAIN)
{
if (!NVRAM_IS_LID_VALID(nvram_reset_req->LID))
{
nvram_reset_confirm(ilm_ptr->src_mod_id, NVRAM_IO_ERRNO_INVALID_LID, nvram_reset_req);
return;
}
/* In Meta mode, we cannot access the data belongs to custom sensitve area
we also cannot reset the important data to prevent security problem */
if (NVRAM_IS_CATEGORY_IMPORTANT(ldi->category)
|| NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category)
#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
|| NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category)
|| NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category)
#endif
)
{
if (FACTORY_BOOT == kal_query_boot_mode() && ilm_ptr->src_mod_id == MOD_FT)
{
nvram_reset_confirm(ilm_ptr->src_mod_id, NVRAM_IO_ERRNO_ACCESS_DENIED, nvram_reset_req);
return;
}
}
}
if (nvram_reset_data_items(nvram_reset_req->reset_category, nvram_reset_req->app_id, ldi, nvram_reset_req->rec_index, nvram_reset_req->rec_amount) == KAL_TRUE)
{
nvram_reset_confirm(ilm_ptr->src_mod_id, NVRAM_ERRNO_SUCCESS, nvram_reset_req);
}
else
{
nvram_reset_confirm(ilm_ptr->src_mod_id, NVRAM_ERRNO_FAIL, nvram_reset_req);
}
}
/* State error */
else
{
nvram_trace(TRACE_FUNC, ERROR_NVRAM_STATE);
nvram_reset_confirm(ilm_ptr->src_mod_id, NVRAM_ERRNO_FAIL, nvram_reset_req);
}
}
} /* end of nvram_reset_handler */
/*****************************************************************************
* FUNCTION
* nvram_config_com_port
* DESCRIPTION
* To init COM port setting
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void custom_em_nvram_config_com_port(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint8 *buffer = NULL;
kal_bool result;
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
kal_bool for_usbat = KAL_FALSE;
#endif
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
buffer = (kal_uint8*) get_ctrl_buffer(NVRAM_EF_PORT_SETTING_SIZE);
if (buffer)
{
port_setting_struct *port_setting;
#if defined(MT6280) && defined(__MODEM_CCCI_EXIST__) && defined(__SMART_PHONE_MODEM__)
result = nvram_external_read_data(NVRAM_EF_PORT_SETTING_LID, 2, buffer, NVRAM_EF_PORT_SETTING_SIZE);
#else
result = nvram_external_read_data(NVRAM_EF_PORT_SETTING_LID, 1, buffer, NVRAM_EF_PORT_SETTING_SIZE);
#endif
/* Ok, now config UART/IrCOMM ports for L4 and TST, and filters to TST */
if (result)
{
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
for_usbat = INT_IsBootForUSBAT();
#endif
port_setting = (port_setting_struct*) buffer;
#ifdef __TST_MODULE__
#ifdef __IRDA_SUPPORT__
if ( (uart_port_irda == (UART_PORT) port_setting->tst_port_ps) ||
(uart_port_irda == (UART_PORT) port_setting->tst_port_l1))
{
init_ircomm_module();
IRDA_Open();
}
#endif /* __IRDA_SUPPORT__ */
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
if (for_usbat)
{
TST_PORT = (UART_PORT) uart_port1;
TST_PORT_L1 = (UART_PORT) uart_port1;
}
else
#endif
{
TST_PORT = (UART_PORT) port_setting->tst_port_ps;
TST_PORT_L1 = (UART_PORT) port_setting->tst_port_l1;
}
TST_BAUDRATE = port_setting->tst_baudrate_ps;
TST_BAUDRATE_L1 = port_setting->tst_baudrate_l1;
#ifndef L4_NOT_PRESENT
#if defined(__BOOT_FOR_USBAT__) && defined(__MTK_TARGET__)
if (for_usbat)
{
PS_UART_PORT = (UART_PORT) uart_port_usb;
}
else
#endif
{
PS_UART_PORT = (UART_PORT) port_setting->ps_port;
}
PS_BAUDRATE = port_setting->ps_baudrate;
#endif /* L4_NOT_PRESENT */
#if defined(__DSP_FCORE4__)
TST_PORT_DSP = (UART_PORT) port_setting->tst_port_dsp;
TST_BAUDRATE_DSP = port_setting->tst_baud_rate_dsp;
#endif //#if defined(__DSP_FCORE4__)
#endif /* __TST_MODULE__ */
High_Speed_SIM = port_setting->High_Speed_SIM_Enabled;
if (High_Speed_SIM)
{
// remove
}
SWDBG_Profile = port_setting->swdbg;
UART_POWER_SETTING = port_setting->uart_power_setting;
CTI_UART_PORT = port_setting->cti_uart_port;
CTI_BAUD_RATE = port_setting->cti_baudrate;
#ifdef __TST_WRITE_TO_FILE__
TST_OUTPUT_MODE = port_setting->tst_output_mode;
#endif
#if defined(__USB_LOGGING__)
g_usb_logging_mode = port_setting->usb_logging_mode;
#endif
#ifdef __MTK_TARGET__
#ifndef __L1_STANDALONE__
/* To determine if in META mode */
if (FACTORY_BOOT != kal_query_boot_mode())
{
//kal_bool enable;
if (custom_em_is_uart_used(uart_port1))
{
custom_em_uart_turnon_power(uart_port1, KAL_TRUE);
}
else
{
custom_em_uart_turnon_power(uart_port1, KAL_FALSE);
}
#ifndef __SMART_PHONE_MODEM__
if (custom_em_is_uart_used(uart_port2))
{
custom_em_uart_turnon_power(uart_port2, KAL_TRUE);
}
else
{
custom_em_uart_turnon_power(uart_port2, KAL_FALSE);
}
if (custom_em_is_uart_used(uart_port3))
{
custom_em_uart_turnon_power(uart_port3, KAL_TRUE);
}
else
{
custom_em_uart_turnon_power(uart_port3, KAL_FALSE);
}
#endif
}
else /* In META Mode, Turn on every UART power */
#endif /* __L1_STANDALONE__ */
{
#ifndef __SMART_PHONE_MODEM__
custom_em_uart_turnon_power(uart_port1, KAL_TRUE);
custom_em_uart_turnon_power(uart_port2, KAL_TRUE);
custom_em_uart_turnon_power(uart_port3, KAL_TRUE);
#endif
}
#endif /* __MTK_TARGET__ */
#ifdef __MULTIPLE_PPP_DIALUP_SUPPORT__ //TRIPLE_PPP for MT6280 IOT
//20120917, support SPEECH(DCT) + TRIPLE PPP IOT test cases
// Target USB Enum, Function, Initial Owner, PC Device Naming
// usb, PPP1, ATCI, MTK Modem
// usb2, PPP23/CMUX, ATCI, MTK Modem
// usb3, AT, ATCI, Application Port
// usb4, Speech, ATCI, Speech Port
// usb5, Catcher Log, TST, Debug Port
TST_PORT = uart_port_usb5;
TST_PORT_L1 = uart_port_usb5;
PS_UART_PORT = uart_port_usb2; //20120917, support SPEECH(DCT) + TRIPLE PPP IOT test cases
g_usb_cdrom_config = 1;
#else
g_usb_cdrom_config = port_setting->usb_cdrom_config;
#endif /* __MULTIPLE_PPP_DIALUP_SUPPORT__ */
#ifdef __SPEECH_OVER_USB__
#ifdef __MTK_TARGET__
SPEECH_PORT = port_setting->speech_port; //uart_port_usb4;
#endif
#endif
}
free_ctrl_buffer(buffer);
}
buffer = NULL;
#if (!defined(L4_NOT_PRESENT)) || defined(__TST_MODULE__)
/* If L4 or TST exist */
buffer = (kal_uint8*) get_ctrl_buffer(NVRAM_EF_TST_FILTER_SIZE);
if (buffer != NULL)
{
result = nvram_external_read_data(NVRAM_EF_TST_FILTER_LID, 1, buffer, NVRAM_EF_TST_FILTER_SIZE);
/* Ok, now config UART/IrCOMM ports for L4 and TST, and filters to TST */
if (result)
{
#ifdef __TST_MODULE__
tst_init_filters((kal_char*) buffer, NVRAM_EF_TST_FILTER_SIZE);
#endif
}
free_ctrl_buffer(buffer);
}
#if defined(__TST_MODULE__) && defined(__MTK_TARGET__)
//Shengkai: check if we need to enable the spare ram logging mechanism
buffer = (kal_uint8*) get_ctrl_buffer(NVRAM_EF_TST_CONFIG_SIZE);
if (buffer != NULL)
{
result = nvram_external_read_data(NVRAM_EF_TST_CONFIG_LID, 1, buffer, NVRAM_EF_TST_CONFIG_SIZE);
if (result)
{
extern kal_bool tst_spare_ram_nvram_enabled_flag;
extern kal_bool tst_alc_logging_enable;
extern kal_bool tst_usb_dma_logging_enabled_flag;
extern kal_uint8 tst_meta_mode_trace_nvram_enable_flag;
extern kal_bool tst_is_auto_memory_dump;
tst_spare_ram_nvram_enabled_flag = ((tst_config_struct_t *)buffer)->spare_logging_enabled;
tst_usb_dma_logging_enabled_flag = ((tst_config_struct_t *)buffer)->usb_dma_logging_enable;
tst_meta_mode_trace_nvram_enable_flag = ((tst_config_struct_t *)buffer)->meta_mode_trace_enable;
if(tst_meta_mode_trace_nvram_enable_flag != 1 && tst_meta_mode_trace_nvram_enable_flag != 2)
tst_meta_mode_trace_nvram_enable_flag = 0;
if(tst_meta_mode_trace_nvram_enable_flag == 2)
tst_is_auto_memory_dump = KAL_TRUE;
if (((tst_config_struct_t *)buffer)->malmo_disable == 1)
tst_alc_logging_enable = KAL_FALSE;
else
tst_alc_logging_enable = KAL_TRUE;
//tst_alc_logging_enable = ~(((tst_config_struct_t *)buffer)->malmo_disable);
}
free_ctrl_buffer(buffer);
}
#endif // #if defined(__TST_MODULE__) && defined(__MTK_TARGET__)
#endif /* (!defined(L4_NOT_PRESENT)) || defined(__TST_MODULE__) */
}
