/*****************************************************************************
* 函 数 名 : bsp_efuse_Write
*
* 功能描述 : 烧写Efsue
*
* 输入参数 : pBuf:待烧写的EFUSE值
* group,Efuse地址偏移
* len,烧写长度
* 输出参数 :
*
* 返 回 值 :
*
* 其它说明 :
*
*****************************************************************************/
int bsp_efuse_write( u32 *pBuf, const u32 group, const u32 len)
{
int length = 0;
u32 chan_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_EFUSE;
EFUSE_DATA_STRU msg ;
if((0 == len) || (group + len > EFUSE_MAX_SIZE) || (NULL == pBuf))
{
efuse_print_error(" parameter error, group=%d, len=%d, pBuf=0x%x.\n", group, len, pBuf);
return EFUSE_ERROR;
}
memcpy(msg.buf, pBuf, EFUSE_GROUP_SIZE * len);
msg.start = group;
msg.len = len;
msg.opt = (u32)EFUSE_WRITE;
osl_sem_down(&efuse_queue_sem_id);
length = bsp_icc_send(ICC_CPU_APP, chan_id, (unsigned char*)&msg, sizeof(EFUSE_DATA_STRU));
if((unsigned int)length != sizeof(EFUSE_DATA_STRU))
{
osl_sem_up(&efuse_queue_sem_id);
efuse_print_error("send len(%x) != expected len(%x).\n", length, sizeof(EFUSE_DATA_STRU));
return EFUSE_ERROR;
}
/* coverity[lock] */
osl_sem_down(&efuse_sem_id);
if(0 != efuse_ret)
{
osl_sem_up(&efuse_queue_sem_id);
efuse_print_error("efuse icc write is fail, err= %d.\n", efuse_ret);
/* coverity[missing_unlock] */
return EFUSE_ERROR;
}
osl_sem_up(&efuse_queue_sem_id);
/* coverity[missing_unlock] */
return EFUSE_OK;
}
/*****************************************************************************
函数 : bsp_fem_power_up
功能 : RF 上电打桩
输入 : 无
输出 : 无
返回 : rf电源开关状态
*****************************************************************************/
int bsp_fem_power_up(PWC_COMM_MODE_E mode, PWC_COMM_MODEM_E modem, PWC_COMM_CHANNEL_E chn)
{
int ret = 0;
osl_sem_down(&rf_pwr_sem[SEM_FEM]);
ret = balong_fem_power_on(mode, modem, chn);
osl_sem_up(&rf_pwr_sem[SEM_FEM]);
return ret;
}
int bsp_om_buf_sem_take(void)
{
if(g_bsp_om_socp_chan_info.init_state == BSP_OM_SOCP_CHAN_INIT_SUCC)
{
osl_sem_down(&om_buf_sem);
}
else
{
return -1;
}
return BSP_OK;
}
/*******************************************************************************
* 函 数 名 : cshell_send_thread
*
* 功能描述 : cshell A核至PC核发送线程
*
* 输入参数 : 无
*
* 输出参数 : 无
*
* 返 回 值 : 无
*
*******************************************************************************/
int cshell_send_thread(void *arg)
{
cshell_ctx_t* cshell_ctx = &g_cshell_ctx;
cshell_mem_handle_t* cshell_send_mem = &cshell_ctx->send_mem[0];
int ret = (int) CSHELL_OK;
printk("A:cshell_send_thread enter\n");
/* coverity[no_escape] */
while (1)
{
osl_sem_down(&(cshell_ctx->cshell_send_sem));
/* 读buffer中有数据或者发送buffer中有剩余数据 */
while ((cshell_send_mem->buf_valid) && (cshell_send_mem->buf_size))
{
cshell_send_mem->buf_valid = 0;
/* 数据复制到USB打印buffer中 */
if(cshell_get_bit(USB_CSHELL) && (cshell_ctx->cshell_acm_fd != 0))
{
write_data_usb_buf(cshell_send_mem);
}
(void)a_cshell_write((int)(cshell_send_mem->buf_size), cshell_send_mem->buf,(int)(cshell_send_mem->buf_size), 1);
if(cshell_get_bit(AUART_CSHELL))
{
print_to_auart(cshell_send_mem);
}
ret = (int)cshell_send_mem->buf_size;
if(ret >= 0)
{
/* 当前处理的buffer为正在写的buffer，则开始使用下一个buffer */
if (cshell_ctx->cshell_send_index == cshell_send_mem->index)
{
/* 考虑在此加锁保护 */
cshell_ctx->cshell_send_index = cshell_send_mem->next->index;
}
cshell_send_mem->buf_size = 0;
cshell_send_mem->buf_valid = 1;
cshell_send_mem = cshell_send_mem->next;
}
else
{
cshell_send_mem->buf_valid = 1;
printk("A: cshell_send_thread send data to acm fail ret [%d],buf_size[%d]\n", ret,cshell_send_mem->buf_size);
}
}
}
}
/*****************************************************************************
函 数 名 : bsp_start_mode_get
功能描述 : 用于C核获取开机模式,通过核间调用, 启动的时候不允许获取
输入参数 :
输出参数 : 无
返 回 值 :
调用函数 :
被调函数 :
*****************************************************************************/
int bsp_start_mode_get( void )
{
int rt = 0;
u32 channel_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_ONOFF;
DRV_START_MODE start_mode = DRV_START_MODE_NORMAL;
stCtrlMsg msg = g_pwrctrl.curr;
if(!g_pwrctrl.is_init)
return start_mode;
if (g_start_mode != (int)DRV_START_MODE_BUILT)
return g_start_mode;
msg.pwr_type = E_POWER_ON_MODE_GET;
msg.mode = DRV_START_MODE_NORMAL;
osl_sem_down(&(g_pwrctrl.pwr_sem));
rt = bsp_icc_send(ICC_CPU_APP, channel_id, (u8*)&msg,
sizeof(stCtrlMsg)); //lint !e40
if(rt != (int)sizeof(stCtrlMsg))
{
osl_sem_up(&(g_pwrctrl.pwr_sem));
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_ONOFF,"[onoff]onoff icc send error, rt=0x%x\n", rt);
return start_mode;
}
/*coverity[lock] */
osl_sem_down(&g_sem_mode);
start_mode = (DRV_START_MODE)g_start_mode;
osl_sem_up(&(g_pwrctrl.pwr_sem));
/*coverity[missing_unlock] */
return start_mode;
}
int bsp_fem_power_down(PWC_COMM_MODE_E mode, PWC_COMM_MODEM_E modem, PWC_COMM_CHANNEL_E chn)
{
int ret = 0;
osl_sem_down(&rf_pwr_sem[SEM_FEM]);
ret = balong_fem_power_off(mode, modem, chn);
if(ret){
rf_print_error("rfic power down faild\n");
ret = RFFE_ERROR;
}
osl_sem_up(&rf_pwr_sem[SEM_FEM]);
return ret;
}
/*****************************************************************************
函 数 名 : uart_send
功能描述 : uart send
输入参数 : UART_HW_PORT* uart_port
BSP_U8 *pbuf
BSP_U32 size
输出参数 : 无
返 回 值 : BSP_S32
*****************************************************************************/
int dual_modem_send_bytes(UART_PORT* uart_port,u8* pbuf,u32 size)
{
u8 * pu8Buffer = NULL;
u32 regval = 0;
pu8Buffer = pbuf;
osl_sem_down(&uart_port->send_mutex);
g_dm_dump_info->send_mutex_cnt++;
g_dm_dump_info->tx_cur_size = size;
g_dm_dump_info->tx_total_size += size;
g_dm_dump_info->send_time_stamp = bsp_get_slice_value();
if(g_dm_dump_info->tx_cur_offset + 4 > DUAL_DUMP_TX_BUFF_SIZE)
{
g_dm_dump_info->tx_cur_offset = 0;
}
(void)memcpy_s((void *)(g_dm_dump_info->tx_dump_addr + g_dm_dump_info->tx_cur_offset), sizeof(u32),
(void *)&g_dm_dump_info->send_time_stamp, sizeof(u32));
g_dm_dump_info->tx_cur_offset += 4;
if(g_dual_modem_ctrl.log_flag == 1)
{
dm_debug_print("TxCurSize %d,TxTotalSize %d\n",g_dm_dump_info->tx_cur_size,g_dm_dump_info->tx_total_size);
(void)dm_print_info(pu8Buffer ,size); /* lint !e532 */
}
while(size)
{
regval = readl(uart_port->base_addr+ UART_REGOFFSET_FR);
if(0 == (regval & UART_FR_TX_FIFO_FULL))
{
writel(*pu8Buffer, uart_port->base_addr + UART_REGOFFSET_THR);
(void)memcpy_s((void *)(g_dm_dump_info->tx_dump_addr + g_dm_dump_info->tx_cur_offset), 1, (void *)pu8Buffer, 1);
g_dm_dump_info->tx_cur_offset++;
if(g_dm_dump_info->tx_cur_offset > DUAL_DUMP_TX_BUFF_SIZE)
{
g_dm_dump_info->tx_cur_offset = 0;
}
pu8Buffer++;
size--;
}
}
osl_sem_up(&uart_port->send_mutex);
return OK;
}
/*测试唤醒源软timer申请和加入链表重复10次，每次都在回调函数修改超时时间*/
s32 st_softtimer_test_case03(void)
{
my_softtimer.func = for_softtimer_test_3;
my_softtimer.para = 2;
my_softtimer.timeout = 10;
my_softtimer.wake_type=SOFTTIMER_WAKE;
osl_sem_init(0,&sem3);
if (bsp_softtimer_create(&my_softtimer))
{
bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_SOFTTIMER,"create error\n");
return ERROR;
}
bsp_softtimer_add(&my_softtimer);
osl_sem_down(&sem3);
osl_sema_delete(&sem3);
return OK;
}
s32 k3_adp_test_case02(void)
{
s32 ret = 0;
osl_sem_init(SEM_EMPTY,&sem);
ret = DRV_TIMER_START(TIMER_ACPU_OSA_ID,func,0,1000,0,TIMER_UNIT_MS);
if(ret!=0)
{
bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_HARDTIMER,"DRV_TIMER_START fail\n");
return ERROR;
}
osl_sem_down(&sem);
ret = DRV_TIMER_STOP(TIMER_ACPU_OSA_ID);
if(ret!=0)
{
bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_HARDTIMER,"DRV_TIMER_START fail\n");
return ERROR;
}
osl_sema_delete(&sem);
return OK;
}
int bsp_om_send_task(void * para)
{
void* send_addr = 0;
u32 buf_len = 0;
u32 ret;
osl_sem_init(SEM_EMPTY,&send_task_sem);
/* coverity[no_escape] */
for(;;)
{
/* 清理RD*/
bsp_om_clean_rd();
/* coverity[check_return] */
osl_sem_down(&send_task_sem);
bsp_om_send_log_buf(BSP_OM_LOG_BUF_TYPE,BSP_PRINT_BUF_LEN);
do
{
bsp_om_get_head_from_list(&send_addr,&buf_len);
if((send_addr != 0)&&(buf_len != 0))
{
ret = bsp_om_send_coder_src(send_addr,buf_len);
if(ret == BSP_OK)
{
bsp_om_del_head_froms_list();
}
else
{
break;
}
}
}while((send_addr != 0)&&(buf_len != 0));
}
/*lint -save -e527 */
return 0;
/*lint -restore +e527 */
}
void bsp_om_send_task(void)
{
u32 send_addr = 0;
u32 buf_len = 0;
u32 ret;
osl_sem_init(SEM_EMPTY,&send_task_sem);
/* coverity[no_escape] */
for(;;)
{
/* 清理RD*/
bsp_om_clean_rd();
//osl_sem_downtimeout(&send_task_sem,3000);
osl_sem_down(&send_task_sem);
bsp_om_send_log_buf(BSP_OM_LOG_BUF_TYPE,BSP_PRINT_BUF_LEN);
do
{
bsp_om_get_head_from_list(&send_addr,&buf_len);
if((send_addr != 0)&&(buf_len != 0))
{
ret = bsp_om_send_coder_src((u8*)send_addr,buf_len);
if(ret == BSP_OK)
{
bsp_om_del_head_froms_list();
}
else
{
break;
}
}
}while((send_addr != 0)&&(buf_len != 0));
}
}
/* 任务处理函数,读取通道里的数据 */
s32 icc_read_task_entry(void *obj)
{
u32 channel_id = (u32)obj;
u32 channel_idx = GET_CHN_ID(channel_id);
u32 sub_chn_idx = GET_FUNC_ID(channel_id);
s32 read_len = 0;
u32 start = 0;
u8 confirm = (u8)ICC_RECV_OK;
s32 i = 0;
u8 buf[ICC_NEW_DATA_LEN] = {0};
icc_print_debug("enter!!!");
for(;g_icc_test.recv_task_flag;)
{
osl_sem_down(&g_icc_test.recv_task_sem);
read_len = bsp_icc_read(channel_id, buf, ICC_NEW_DATA_LEN);
if(read_len < 0 || read_len > ICC_NEW_DATA_LEN)
{
confirm = (u8)ICC_RECV_ERR;
}
else
{
for(i = 0; i < read_len; i++)
{
if(((u8)i + start) != buf[i])
{
confirm = (u8)ICC_RECV_ERR;
}
}
confirm = ICC_CONF_MSG_TYPE2;
}
icc_print_debug("channel_id=0x%x, confirm=0x%x\n", channel_id, confirm);
bsp_icc_send(g_icc_dbg.send_cpu_id, (channel_idx << 16) | (sub_chn_idx - 1), &confirm, sizeof(confirm));
}
return 0;
}
int modem_reset_task(void *arg)
{
u16 action = 0;
unsigned long flags = 0;
for( ; ;)
{
osl_sem_down(&(g_modem_reset_ctrl.task_sem));
action = (u16)g_modem_reset_ctrl.modem_action;
reset_print_debug("(%d)has taken task_sem, action=%d\n", ++g_reset_debug.main_stage, action);
if (MODEM_POWER_OFF == action)
{
(void)do_power_off(action);
}
else if (MODEM_POWER_ON == action)
{
(void)do_power_on(action);
}
else if (MODEM_RESET == action)
{
(void)do_reset(action);
reset_print_err("reset count: %d\n", ++g_modem_reset_ctrl.reset_cnt);
}
if (action == g_modem_reset_ctrl.modem_action)
{
spin_lock_irqsave(&g_modem_reset_ctrl.action_lock, flags);
g_modem_reset_ctrl.modem_action = MODEM_NORMAL;
spin_unlock_irqrestore(&g_modem_reset_ctrl.action_lock, flags);
}
wake_unlock(&(g_modem_reset_ctrl.wake_lock));
g_modem_reset_ctrl.exec_time = get_timer_slice_delta(g_modem_reset_ctrl.exec_time, bsp_get_slice_value());
reset_print_debug("execute done, elapse time %d\n", g_modem_reset_ctrl.exec_time);
}
}
/*****************************************************************************
函数 : bsp_rffe_cfg_on_power_down
功能 : 开机时mipi和线控配置
输入 : 无
输出 : 无
返回 : mipi配置是否成功，0为成功,1为失败
*****************************************************************************/
int bsp_rffe_cfg_on_power_down(PWC_COMM_MODE_E mode, PWC_COMM_MODEM_E modem, PWC_COMM_CHANNEL_E chn)
{
u64 cur_state = 0;
u32 vote_bit = 0;
int ret = 0;
int power_flag = 0;
vote_bit = RF_PWR_MODE_NUM * modem + mode;
osl_sem_down(&rf_pwr_sem[SEM_FEM]);
cur_state = rffe_cfg.vote[chn];
rffe_cfg.vote[chn] &= ~((u64)1 << vote_bit);
if((0 == rffe_cfg.vote[chn]) && cur_state){
ret = balong_rf_config_by_mipi_modem_off(chn);
ret |= balong_rf_config_anten_poweroff(chn);
rffe_cfg.true_pwroff_cnt[chn]++;
rffe_cfg.true_pwroff_time_stamp[chn] = bsp_get_slice_value();
}
power_flag = balong_fem_power_status(mode,modem, chn);
if(!power_flag){
ret = balong_rf_config_by_mipi_allmodem_off();
ret |= balong_rf_config_anten_allpoweroff();
rffe_cfg.true_alloff_cnt++;
rffe_cfg.true_alloff_time_stamp = bsp_get_slice_value();
}
rffe_cfg.pwroff_cnt[chn]++;
rffe_cfg.pwroff_time_stamp[chn] = bsp_get_slice_value();
osl_sem_up(&rf_pwr_sem[SEM_FEM]);
return ret;
}
/*****************************************************************************
* 函 数 名 : cshell_io_send
*
* 功能描述 : 发送数据到A核
*
* 输入参数 : SHELL_IO_CHAN *ptr_shell :shell指针
* 输出参数 : 无
*
* 返 回 值 : 无
*
* 修改记录 :
*****************************************************************************/
void cshell_io_send(void)
{
SHELL_IO_CHAN *ptr_shell = &shell_io_channel;
unsigned int data_size = 0;
unsigned int len_send2icc = 0;
int wr_len = 0;
int ret = 0;
cshell_print_debug("enter handler\n");
/* coverity[no_escape] */
for(;;)
{
//semTake(ptr_shell->cshell_recv_sem, WAIT_FOREVER);
osl_sem_down(&(ptr_shell->cshell_recv_sem));
/* 有数据, 要处理 */
while (OK == (ret = (ptr_shell->get_tx_char)(ptr_shell->get_tx_arg, (ptr_shell->ptr_send_buf + ptr_shell->send_rd))))
{
(void)dmesg_write((const char *)(ptr_shell->ptr_send_buf + ptr_shell->send_rd), sizeof(char));
/* buffer满, 抛掉旧数据 */
if(((ptr_shell->send_rd + 1) & (IO_BUFFER_MAX*2 - 1)) == ptr_shell->send_wt)
{
ptr_shell->send_wt = ptr_shell->send_wt + 1;
ptr_shell->send_wt &= (IO_BUFFER_MAX*2 - 1);
++g_cshell_dbg.lost_data_cnt;
}
++ptr_shell->send_rd;
ptr_shell->send_rd &= (IO_BUFFER_MAX*2 - 1);
}
/* 超过水位线, 调用icc发送接口将数据发给acore ACM */
data_size = (ptr_shell->send_rd + IO_BUFFER_MAX*2 - ptr_shell->send_wt) & (IO_BUFFER_MAX*2 - 1);
while(data_size && ptr_shell->cshell_send_permission)
{
len_send2icc = min(data_size, CSHELL_ICC_FIFO_DEPTH);
if (ptr_shell->send_rd < ptr_shell->send_wt)
{
len_send2icc = min(len_send2icc, (unsigned int)(IO_BUFFER_MAX*2 - ptr_shell->send_wt));
}
wr_len = bsp_icc_send(ICC_CPU_APP, ptr_shell->icc_channel_id,
ptr_shell->ptr_send_buf + ptr_shell->send_wt, len_send2icc);
if(wr_len < 0) /* 发送失败 */
{
++g_cshell_dbg.send_fail_cnt;
break;
}
else if(wr_len < (s32)len_send2icc) /* icc通道不顺畅,暂时退出发送 */
{
++g_cshell_dbg.send_busy_cnt;
ptr_shell->send_wt = (ptr_shell->send_wt + wr_len) & (IO_BUFFER_MAX*2 - 1);
data_size -= (unsigned int)wr_len;/* [false alarm]:误报 */
break;
}
else if(wr_len == (s32)len_send2icc) /* 顺利将所有数据发送走 */
{
++g_cshell_dbg.send_succ_cnt;
ptr_shell->send_wt = (ptr_shell->send_wt + wr_len) & (IO_BUFFER_MAX*2 - 1);
data_size -= (unsigned int)wr_len;
}
}
}
}
/*
* Function : sc_icc_task
* Discription: c core nv init,this phase build upon the a core kernel init,
* this phase after icc init,this phase ensure to use all nv api normal
* start at this phase ,ops global ddr need spinlock
* Parameter : none
* Output : result
* History :
*/
void sc_icc_task(void)
{
s32 ret = -1;
s32 icc_len = 0;
sc_icc_stru icc_trans;
/* coverity[no_escape] */
for(;;)
{
osl_sem_down(&g_sc_stat.sc_tsk_sem);
sc_debug_printf("icc task, recv from acore ok, chanid :0x%x\n",SC_ICC_CHAN_ID);
icc_len = bsp_icc_read(SC_ICC_CHAN_ID, (u8 * )&icc_trans, sizeof(sc_icc_stru));
if((icc_len > sizeof(sc_icc_stru)))
{
sc_error_printf("bsp icc read error, chanid :0x%x opt_len :0x%x\n",SC_ICC_CHAN_ID,icc_len);
osl_sem_up(&g_sc_stat.sc_tsk_sem);
continue;
}
else if(0 >= icc_len)
{
sc_debug_printf("bsp icc read error, length is 0!\n");
continue ;
}
g_sc_stat.sc_ram_len = icc_trans.sc_total_len;
sc_debug_printf("len is 0x%x\n", g_sc_stat.sc_ram_len);
icc_trans.sc_cnf_ret = SC_OK;
/* get buffer */
g_sc_stat.sc_ram_addr = (u8* )osl_malloc(icc_trans.sc_total_len);
if(!g_sc_stat.sc_ram_addr)
{
sc_error_printf("bsp icc read error, chanid :0x%x ret :0x%x\n",SC_ICC_CHAN_ID,ret);
icc_trans.sc_cnf_ret = BSP_ERR_SC_MALLOC_FAIL;
goto confirm;
}
else
{
sc_debug_printf("malloc ok!\n");
}
if(MISC_SC_OPT_WRITE== icc_trans.sc_opt_type)
{
if(SC_OK != sc_bakup(g_sc_stat.sc_ram_addr, g_sc_stat.sc_ram_len))
{
icc_trans.sc_cnf_ret = BSP_ERR_SC_WRITE_FILE_FAIL;
}
}
else
{
if(SC_OK != sc_restore(g_sc_stat.sc_ram_addr, g_sc_stat.sc_ram_len))
{
icc_trans.sc_cnf_ret = BSP_ERR_SC_READ_FILE_FAIL;
}
}
osl_free(g_sc_stat.sc_ram_addr);
confirm:
/* send pkt to modem */
icc_len = bsp_icc_send(ICC_CPU_MODEM, SC_ICC_CHAN_ID, (u8*)&icc_trans, sizeof(sc_icc_stru));
if(icc_len != sizeof(sc_icc_stru))
{
sc_error_printf("send to modem failed 0,icc_len is 0x%x!\n",icc_len);
}
else
{
sc_debug_printf("send to mdoem ok,icc_len is 0x%x!\n",icc_len);
}
continue;
}
}
/*****************************************************************************
函 数 名 : dual_modem_uart_recv_task
功能描述 : 调用回调函数，向上层发送数据
输入参数 : UART_PORT * uart_port_add 端口地址
输出参数 : 无
返 回 值 : void
*****************************************************************************/
void dual_modem_uart_recv_task(UART_PORT *uart_port_addr)
{
s32 ret = 0;
volatile u32 ulwrite = 0;
volatile u32 this_size = 0;
UART_PORT *uart_port = NULL;
RECV_STR *recvStr = NULL;
recvStr = &g_dual_modem_ctrl.uart_port.circ_buf;
if(NULL == uart_port_addr)
{
dm_print_err("uart_port_addr is null\n");
return ;
}
uart_port = uart_port_addr;
while(1)
{
osl_sem_down(&g_dual_modem_ctrl.recv_mutex);
cpcp_msg_count_record(&g_dm_dump_info->rtask_SemTake_cnt, "RtaskSemTakecnt");
ulwrite = recvStr->ulWrite;
bsp_softtimer_delete(&g_dual_modem_ctrl.sleep_timer);
dual_modem_restart_timer(&g_dual_modem_ctrl.hold_wake_timer);
g_dual_modem_ctrl.wakeup_3rdmodem_flag = NOT_WAKEUP_V3;
if(NULL != uart_port->recv_callback)
{
if(recvStr->ulRead == ulwrite)
{
dual_modem_restart_timer(&g_dual_modem_ctrl.sleep_timer);
continue;
}
if(recvStr->ulRead < ulwrite)
{
this_size = ulwrite - recvStr->ulRead;
if((g_dm_dump_info->rx_cur_offset + this_size + 4) > DUAL_DUMP_RX_BUFF_SIZE)
{
g_dm_dump_info->rx_cur_offset = 0;
}
(void)memcpy_s((void *)(g_dm_dump_info->rx_dump_addr + g_dm_dump_info->rx_cur_offset), sizeof(u32),
(void *)&g_dm_dump_info->recv_time_stamp, sizeof(u32));
g_dm_dump_info->rx_cur_offset += 4;
(void)memcpy_s((g_dm_dump_info->rx_dump_addr + g_dm_dump_info->rx_cur_offset) ,this_size,(recvStr->ucData + recvStr->ulRead), this_size);
g_dm_dump_info->rx_cur_offset += this_size;
ret = uart_port->recv_callback(CBP_UART_PORT_ID,(recvStr->ucData + recvStr->ulRead),this_size); /* [false alarm]:误报 */
g_dm_dump_info->rx_cur_size = this_size;
g_dm_dump_info->rx_total_size += this_size;
if(g_dual_modem_ctrl.log_flag == 1)
{
dm_debug_print("RecvCurSize %d\n",this_size);
dm_print_info((recvStr->ucData + recvStr->ulRead),this_size);
}
}
else
{
this_size = UART_RECV_BUF_SIZE - recvStr->ulRead;
if((g_dm_dump_info->rx_cur_offset + this_size + 4) > DUAL_DUMP_RX_BUFF_SIZE)
{
g_dm_dump_info->rx_cur_offset = 0;
}
(void)memcpy_s((void *)(g_dm_dump_info->rx_dump_addr + g_dm_dump_info->rx_cur_offset), sizeof(u32),
(void *)&g_dm_dump_info->recv_time_stamp, sizeof(u32));
g_dm_dump_info->rx_cur_offset += 4;
(void)memcpy_s((g_dm_dump_info->rx_dump_addr + g_dm_dump_info->rx_cur_offset) ,this_size,(recvStr->ucData + recvStr->ulRead), this_size);
g_dm_dump_info->rx_cur_offset += this_size;
ret = uart_port->recv_callback(CBP_UART_PORT_ID,(recvStr->ucData + recvStr->ulRead),this_size); /* [false alarm]:误报 */
g_dm_dump_info->rx_cur_size = this_size + ulwrite;
g_dm_dump_info->rx_total_size += this_size;
if(g_dual_modem_ctrl.log_flag == 1)
{
dm_debug_print("RecvCurSize %d\n",g_dm_dump_info->rx_cur_size);
dm_print_info((recvStr->ucData + recvStr->ulRead),this_size);
}
if(ulwrite)
{
this_size = ulwrite;
if((g_dm_dump_info->rx_cur_offset + this_size + 4) > DUAL_DUMP_RX_BUFF_SIZE)
{
g_dm_dump_info->rx_cur_offset = 0;
}
(void)memcpy_s((void *)(g_dm_dump_info->rx_dump_addr + g_dm_dump_info->rx_cur_offset), sizeof(u32),
(void *)&g_dm_dump_info->recv_time_stamp, sizeof(u32));
g_dm_dump_info->rx_cur_offset += 4;
(void)memcpy_s((g_dm_dump_info->rx_dump_addr + g_dm_dump_info->rx_cur_offset),this_size ,recvStr->ucData , this_size);
g_dm_dump_info->rx_cur_offset += this_size;
ret = uart_port->recv_callback(CBP_UART_PORT_ID,recvStr->ucData,this_size); /* [false alarm]:误报 */
g_dm_dump_info->rx_total_size += this_size;
if(g_dual_modem_ctrl.log_flag == 1)
{
dm_print_info(recvStr->ucData,this_size);
}
}
}
recvStr->ulRead = ulwrite;
if(OK != ret)
{
dm_print_err("recv error!!\n");
}
}
else
{
dm_print_err("callback is null\n");
g_dm_dump_info->callback_fail_cnt++;
recvStr->ulRead = ulwrite;
}
dual_modem_restart_timer(&g_dual_modem_ctrl.sleep_timer);
}
}
FILE* nv_emmc_open(const s8* path,const s8* mode)
{
u32 ret = NV_ERROR;
u32 i = 0;
struct nv_emmc_file_header_stru* fd = NULL;
u32 offset = 0;
u32 len = 0;
struct mtd_info* mtd = NULL;
nv_file_debug(NV_FILE_OPEN_API,0,0,0,0);
for(i=0; i<NV_FILE_BUTT; i++)
{
if(0 == strcmp(path,g_nv_file[i].path))
{
fd = &g_nv_file[i];
mtd = get_mtd_device_nm(fd->name);
if(IS_ERR(mtd))
{
printf("[%s]:get mtd device err! %s\n",__func__,fd->name);
return NULL;
}
g_nv_file[i].mtd = mtd;
break;
}
}
if(NULL == fd)
{
nv_file_debug(NV_FILE_OPEN_API,1,0,0,0);
return NULL;
}
osl_sem_down(&fd->file_sem);
switch(fd->emmc_type)
{
case NV_FILE_DLOAD:
ret = nv_get_nvbin_info(mode,&offset,&len);
break;
case NV_FILE_BACKUP:
ret = nv_sec_file_info_init(g_nv_file[NV_FILE_BACKUP].name,&g_emmc_info.bak_sec);
ret |= nv_get_back_info(mode,&offset,&len);
break;
case NV_FILE_XNV_CARD_1:
ret = nv_get_xnv_info(NV_USIMM_CARD_1,&offset,&len);
break;
case NV_FILE_CUST_CARD_1:
ret = nv_get_cust_info(NV_USIMM_CARD_1,&offset,&len);
break;
case NV_FILE_XNV_CARD_2:
ret = nv_get_xnv_info(NV_USIMM_CARD_2,&offset,&len);
break;
case NV_FILE_CUST_CARD_2:
ret = nv_get_cust_info(NV_USIMM_CARD_2,&offset,&len);
break;
case NV_FILE_SYS_NV:
ret = nv_get_sys_nv_info(mode,&offset,&len);
break;
case NV_FILE_DEFAULT:
ret = nv_get_default_info(mode,&offset,&len);
break;
case NV_FILE_XNV_MAP_CARD_1:
ret = nv_get_xnv_map_info(NV_USIMM_CARD_1,&offset,&len);
break;
case NV_FILE_XNV_MAP_CARD_2:
ret = nv_get_xnv_map_info(NV_USIMM_CARD_2,&offset,&len);
break;
default:
ret = BSP_ERR_NV_INVALID_PARAM;
}
if(NV_OK != ret)
{
put_mtd_device(fd->mtd);
osl_sem_up(&fd->file_sem);
nv_file_debug(NV_FILE_OPEN_API,3,fd->emmc_type,ret,0);
return NULL;
}
fd->ops ++;
fd->seek = 0;
fd->length = len;
fd->off = offset;
fd->fp = fd;
return fd;
}
u32 bsp_om_send_coder_src(u8 *send_data_virt, u32 send_len)
{
SOCP_BUFFER_RW_STRU bd_buf = {0};
u32 ulBDNum;
SOCP_BD_DATA_STRU bd_data = {0};
u32 send_data_phy = 0;
u32 ret;
osl_sem_down(&socp_opt_sem);
/* 将用户虚拟地址转换成物理地址*/
send_data_phy = bsp_om_virt_phy((void *)send_data_virt);
if(send_data_phy == 0)
{
ret = BSP_ERR_OMS_INVALID_PARAM;
goto fail;
}
bsp_socp_get_write_buff(g_bsp_om_socp_chan_info.en_src_chan_id, &bd_buf);
/* 计算空闲BD的值 */
ulBDNum = (bd_buf.u32Size + bd_buf.u32RbSize)/ sizeof(SOCP_BD_DATA_STRU);
/* 判断是否还有空间 */
if (1 >= ulBDNum)
{
bsp_om_debug(BSP_LOG_LEVEL_ERROR," GET BD fail,ulBDNum = %d\n",ulBDNum);
ret = BSP_ERR_OMS_SOCP_GET_BD_NUM_ERR;
goto fail;
}
/*SOCP给出的是物理地址*/
if(NULL == bd_buf.pBuffer )
{
bsp_om_debug(BSP_LOG_LEVEL_ERROR," GET BD fail,pBuffer = NULL \n");
ret = BSP_ERR_OMS_SOCP_BD_ADDR_ERR;
goto fail;
}
bd_data.pucData = send_data_phy;
bd_data.usMsgLen = (BSP_U16)send_len;
bd_data.enDataType = SOCP_BD_DATA;
memcpy((void *)bsp_om_phy_virt(((uintptr_t)bd_buf.pBuffer)),(void*)&bd_data,sizeof(SOCP_BD_DATA_STRU));
/*lint -save -e713*/
dma_map_single(NULL, (void*)bsp_om_phy_virt(((uintptr_t)bd_buf.pBuffer)), sizeof(SOCP_BD_DATA_STRU), DMA_TO_DEVICE);
dma_map_single(NULL, (void *)(send_data_virt), send_len, DMA_TO_DEVICE);
/*lint -restore*/
ret = (u32)bsp_socp_write_done(g_bsp_om_socp_chan_info.en_src_chan_id, sizeof(SOCP_BD_DATA_STRU)) ; /* 当前数据写入完毕 */
if(ret != BSP_OK)
{
goto fail;
}
else
{
ret = BSP_OK;
goto successful;
}
fail:
osl_sem_up(&socp_opt_sem);
return ret;
successful:
osl_sem_up(&socp_opt_sem);
return ret;
}
/*****************************************************************************
函 数 名 : mdrv_loadas
功能描述 : 对外提供的镜像加载接口
输入参数 : rat_mode 镜像类型
输出参数 : 成功返回0，失败返回非0
*****************************************************************************/
int mdrv_loadas ( DRV_RAT_MODE_ENUM rat_mode )
{
s32 ret = BSP_OK;
loadps_msg loadps_msg;
u32 elapsed;
int overlay_index = 0;
int magic =0 ;
int page_left=0;
struct loadps_header *pheader;
struct ovly_addr_info *pRat_addr_info, *pOvly_addr_info;
/*保证一次只有一个任务执行loadps*/
osl_sem_down ( &loadps_mutex );
g_loadps_debuginfo.call_cnt++;
loadps_trace(BSP_LOG_LEVEL_INFO ,"rat_mode %d\n" ,rat_mode);
g_loadps_debuginfo.mdrv_start_ms = bsp_get_elapse_ms();
if ((DRV_RAT_MODE_UMTS_FDD != rat_mode) && (DRV_RAT_MODE_UMTS_TDD != rat_mode))
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"rat_mode ERROR! %d\n" ,rat_mode);
ret = -1;
goto sem_up;
}
/*判断一下加载的镜像*/
if (rat_mode == DRV_RAT_MODE_UMTS_TDD)
{
overlay_index = 1;
magic = 0x00736174;
}
else if (rat_mode == DRV_RAT_MODE_UMTS_FDD)
{
overlay_index = 2;
magic = 0x00736177;
}
g_loadps_debuginfo.rat_mode = rat_mode;
pRat_addr_info = _ovly_table + overlay_index;
pOvly_addr_info = _ovly_table;
(void)memset_s(&loadps_msg, sizeof(loadps_msg), 0x0, sizeof(loadps_msg));
loadps_msg.rat_mode = rat_mode;
/*加载到内存中的地址*/
loadps_msg.addr = pRat_addr_info->addr;
g_loadps_debuginfo.load_addr = loadps_msg.addr;
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps_msg.addr 0x%x\n" ,loadps_msg.addr);
loadps_msg.size = pRat_addr_info->size;
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps_msg.size 0x%x\n" ,loadps_msg.size);
ret = bsp_icc_send( ICC_CPU_APP, LOADPS_ICC_IFC_ID, (u8*)(&loadps_msg), sizeof(loadps_msg));
if (sizeof(loadps_msg) != ret )
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"msg_size != ret: msg_size = 0x%x, ret = 0x%x\n", sizeof(loadps_msg), ret);
ret = -1;
goto sem_up;
}
g_loadps_debuginfo.send_icc_cnt++;
/*把任务挂起,等待A核把镜像搬运的工作完成*/
osl_sem_down ( &loadps_wait_complete_mutex );
/*C核的任务被唤醒后执行*/
g_loadps_debuginfo.recv_icc_cnt++;
g_loadps_debuginfo.mdrv_wakeup_byacore_ms = bsp_get_elapse_ms();
elapsed = g_loadps_debuginfo.mdrv_wakeup_byacore_ms - g_loadps_debuginfo.mdrv_start_ms;
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps result = 0x%x and icc complete time %d ms\n", g_loadps_status.result,elapsed);
ret = g_loadps_status.result;
if(ret != 0)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"loadps result = 0x%x\n", ret);
ret = -1;
goto sem_up;
}
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps SRE_ICacheInv addr = 0x%x size= 0x %x\n", pOvly_addr_info->addr, pOvly_addr_info->size);
ret = SRE_ICacheInv((VOID *)pOvly_addr_info->addr, (UINT32)pOvly_addr_info->size, TRUE);
if(ret != 0)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"SRE_ICacheInv error = 0x%x\n", ret);
ret = -1;
goto sem_up;
}
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps SRE_DCacheInv addr = 0x%x size= 0x %x\n", pOvly_addr_info->addr, pOvly_addr_info->size);
ret = SRE_DCacheInv((VOID *)pOvly_addr_info->addr, (UINT32)pOvly_addr_info->size, TRUE);
if(ret != 0)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"SRE_DCacheInv error = 0x%x\n", ret);
ret = -1;
goto sem_up;
}
pheader = (struct loadps_header *)pRat_addr_info->addr;
if (pheader->magic != magic)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"pheader->magic error = 0x%x\n", pheader->magic);
ret = -1;
goto sem_up;
}
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps pheader->text_start= 0x%x pheader->text_size= 0x %x\n", pheader->text_start, pheader->text_size);
/*设置代码段只读可执行属性*/
ret = SRE_MmuStateSet(pheader->text_start, pheader->text_size, 0, LOADPS_TEXT_MMU_ATTR);
if(ret != 0)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"SRE_MmuStateSet TEXT error = 0x%x\n", ret);
ret = -1;
goto sem_up;
}
loadps_trace(BSP_LOG_LEVEL_INFO,"loadps pheader->data_start= 0x%x pheader->data_size= 0x %x\n", pheader->data_start, pheader->data_size);
if( pheader->data_size % PAGE_SIZE)
{
page_left = pheader->data_size % PAGE_SIZE;
page_left = PAGE_SIZE - page_left;
}
/*设置数据段可读写属性*/
ret = SRE_MmuStateSet(pheader->data_start, pheader->data_size+page_left, 0, LOADPS_DATA_MMU_ATTR);
if(ret != 0)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"SRE_MmuStateSet data error = 0x%x\n", ret);
ret = -1;
goto sem_up;
}
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps pheader->bss_start= 0x%x pheader->bss_size= 0x %x\n", pheader->bss_start, pheader->bss_size);
/*清除bss段的内容*/
memset_s((void*)pheader->bss_start, pheader->bss_size, 0x0, pheader->bss_size);
/*Unwind信息的添加，方便打印私有镜像的调用栈信息*/
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps pheader->unwind_start= 0x%x pheader->unwind_size= 0x %x\n", pheader->unwind_start, pheader->unwind_size);
ret = SRE_UnwindTableAdd(pheader->unwind_start, pheader->unwind_start + pheader->unwind_size,\
pheader->text_start, pheader->text_start + pheader->text_size);
if(ret != 0)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"SRE_UnwindTableAdd error = 0x%x\n", ret);
ret = -1;
goto sem_up;
}
/*符号表信息增加*/
loadps_trace(BSP_LOG_LEVEL_INFO ,"loadps pheader->symbol_start= 0x%x pheader->symbol_size= 0x %x\n", pheader->symbol_start, (pheader->symbol_size)/sizeof(OS_SYMBOL_NODE_S));
/* Add Symbol table for this overlay section */
ret = SRE_SymbolTableAdd((OS_SYMBOL_NODE_S*)pheader->symbol_start, (pheader->symbol_size)/sizeof(OS_SYMBOL_NODE_S), \
pRat_addr_info->addr, pRat_addr_info->addr + pRat_addr_info->size);
if(ret != 0)
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"SRE_SymbolTableAdd error = 0x%x\n", ret);
ret = -1;
goto sem_up;
}
sem_up:
osl_sem_up ( &loadps_mutex );
g_loadps_debuginfo.mdrv_SymbolTableAdd_ms = bsp_get_elapse_ms();
elapsed = g_loadps_debuginfo.mdrv_SymbolTableAdd_ms - g_loadps_debuginfo.mdrv_start_ms;
loadps_trace(BSP_LOG_LEVEL_ERROR ,"loadps total load time %d ms ret = %d\n", elapsed, ret);
g_loadps_debuginfo.mdrv_total_elapsed_ms = elapsed;
if(!ret)
{
g_loadps_debuginfo.succ_cnt++;
}
return ret;
}
* 函 数 名 : bsp_om_socp_clean_rd_buf
*
* 功能描述 :清理SOCP的RD缓存
*
* 输入参数 :chan_id :socp 的通道ID
* rd_stru: 入参
*
* 输出参数 :无
*
* 返 回 值 : BSP_OK 成功; 其他 失败
*****************************************************************************/
u32 bsp_om_socp_clean_rd_buf(u32 chan_id,SOCP_BUFFER_RW_STRU *rd_stru)
{
u32 ret;
SOCP_BUFFER_RW_STRU rd_buf_stru = {0};
osl_sem_down(&socp_opt_sem);
ret = (u32)bsp_socp_get_rd_buffer(chan_id,&rd_buf_stru);
if(BSP_OK != ret)
{
ret = BSP_ERR_OMS_SOCP_GET_RD_ERR;
goto fail;
}
/* 无RD需要释放*/
if( (0 ==rd_buf_stru.u32Size)&&(0 == rd_buf_stru.u32RbSize))
{
ret = BSP_OK;
goto successful;
}
/* 获取到的RD数据异常*/
if((rd_buf_stru.u32Size + rd_buf_stru.u32RbSize) > BSP_OM_CODER_SRC_RDSIZE)
{
ret = BSP_ERR_OMS_SOCP_CLEAN_RD_ERR;
goto fail;
}
if(0 != (rd_buf_stru.u32Size / sizeof(SOCP_RD_DATA_STRU)))
{
rd_stru->pBuffer = rd_buf_stru.pBuffer;
rd_stru->u32Size = rd_buf_stru.u32Size;
(void)cacheInvalidate(DATA_CACHE, rd_buf_stru.pBuffer, rd_buf_stru.u32Size);
}
else
{
ret = BSP_ERR_OMS_SOCP_CLEAN_RD_ERR;
goto fail;
}
ret = (u32)bsp_socp_read_rd_done(chan_id, rd_buf_stru.u32Size); /* 释放rd缓存 */
if( BSP_OK !=ret)
{
goto fail;
}
else
{
ret = BSP_OK;
goto successful;
}
fail:
osl_sem_up(&socp_opt_sem);
return ret;
successful:
osl_sem_up(&socp_opt_sem);
return ret;
}
u32 bsp_om_socp_clean_rd_buf(u32 chan_id,SOCP_BUFFER_RW_STRU *rd_stru)
{
u32 ret;
SOCP_BUFFER_RW_STRU rd_buf_stru = {0};
osl_sem_down(&socp_opt_sem);
ret = (u32)bsp_socp_get_rd_buffer(chan_id,&rd_buf_stru);
if(BSP_OK != ret)
{
ret = BSP_ERR_OMS_SOCP_GET_RD_ERR;
goto fail;
}
/* 无RD需要释放*/
if( (0 ==rd_buf_stru.u32Size)&&(0 == rd_buf_stru.u32RbSize))
{
ret = BSP_OK;
goto successful;
}
/* 获取到的RD数据异常*/
if((rd_buf_stru.u32Size + rd_buf_stru.u32RbSize) > BSP_OM_CODER_SRC_RDSIZE)
{
ret = BSP_ERR_OMS_SOCP_CLEAN_RD_ERR;
goto fail;
}
if(0 != (rd_buf_stru.u32Size / sizeof(SOCP_RD_DATA_STRU)))
{
/*lint -save -e713*/
dma_map_single(NULL, (void *)bsp_om_phy_virt(((uintptr_t)rd_buf_stru.pBuffer)), rd_buf_stru.u32Size, DMA_FROM_DEVICE);
/*lint -restore*/
rd_stru->pBuffer = (char *)bsp_om_phy_virt(((uintptr_t)rd_buf_stru.pBuffer));
rd_stru->u32Size = rd_buf_stru.u32Size;
}
else
{
ret = BSP_ERR_OMS_SOCP_CLEAN_RD_ERR;
goto fail;
}
ret = (u32)bsp_socp_read_rd_done(chan_id, rd_buf_stru.u32Size); /* 释放rd缓存 */
if( BSP_OK !=ret)
{
goto fail;
}
else
{
ret = BSP_OK;
goto successful;
}
fail:
osl_sem_up(&socp_opt_sem);
return ret;
successful:
osl_sem_up(&socp_opt_sem);
return ret;
}
/* 新增mcore后, 三核共用的测试代码开始 2012/06/13*/
s32 bsp_icc_mcore_test_init(void)
{
u32 mcoore_test_channel_size = 0;
u32 channel_idx[2]={0};
s32 ret = ICC_OK;
u32 i = 0;
if(ICC_TEST_CASE_INITILIZED == g_icc_test.mcore_test_state)
{
icc_print_error("icc mcore test has initilized\n");
return ICC_OK;
}
icc_print_debug("icc mcore test initilizing\n");
#ifdef __KERNEL__
mcoore_test_channel_size = 1;
channel_idx[0] = ICC_CHN_MCORE_ACORE;
#elif defined( __VXWORKS__)
mcoore_test_channel_size = 1;
channel_idx[0] = ICC_CHN_MCORE_CCORE;
#elif defined(__CMSIS_RTOS) /* rtx(cm3 os) */
mcoore_test_channel_size = 2;
channel_idx[0] = ICC_CHN_MCORE_CCORE;
channel_idx[1] = ICC_CHN_MCORE_ACORE;
#endif
for(i = 0; i < mcoore_test_channel_size; i++)
{
/* 20个子通道, 现有16个子通道的基础上再分配4个 */
ret = icc_test_channel_reinit(channel_idx[i], ICC_TEST_MCORE_CHN_SIZE);
if(ICC_OK != ret)
{
icc_print_error("icc_test_channel_reinit error\n");
return ICC_ERR;
}
/* 使用后4个子通道进行测试 */
ret = icc_test_sub_chn_init(channel_idx[i], ICC_TEST_USE_CHN_SIZE, ICC_TEST_MCORE_START_CHN);
if(ICC_OK != ret)
{
icc_print_error("icc_test_sub_chn_init error\n");
return ICC_ERR;
}
}
#ifdef __CMSIS_RTOS
g_icc_test.channels[ICC_CHN_MCORE_CCORE].sub_channels[16].confirm_sem = osl_sem_init(1, confirm_sem01);/*lint !e416 !e831*/
g_icc_test.channels[ICC_CHN_MCORE_CCORE].sub_channels[18].confirm_sem = osl_sem_init(1, confirm_sem02);/*lint !e416 !e831*/
g_icc_test.channels[ICC_CHN_MCORE_ACORE].sub_channels[16].confirm_sem = osl_sem_init(1, confirm_sem03);/*lint !e416 !e831*/
g_icc_test.channels[ICC_CHN_MCORE_ACORE].sub_channels[18].confirm_sem = osl_sem_init(1, confirm_sem04);/*lint !e416 !e831*/
osl_sem_down(&(g_icc_test.channels[ICC_CHN_MCORE_CCORE].sub_channels[16].confirm_sem));/*lint !e416 !e831*/
osl_sem_down(&(g_icc_test.channels[ICC_CHN_MCORE_CCORE].sub_channels[18].confirm_sem));/*lint !e416 !e831*/
osl_sem_down(&(g_icc_test.channels[ICC_CHN_MCORE_ACORE].sub_channels[16].confirm_sem));/*lint !e416 !e831*/
osl_sem_down(&(g_icc_test.channels[ICC_CHN_MCORE_ACORE].sub_channels[18].confirm_sem));/*lint !e416 !e831*/
#endif
#ifdef ICC_HAS_DEBUG_FEATURE
/* 测试打开打印开关 */
icc_dbg_print_sw(0);
#endif
/* 状态最后更新 */
g_icc_test.mcore_test_state = ICC_TEST_CASE_INITILIZED;
return ICC_OK;
}
