BSP_S32 BSP_ICC_Ioctl(BSP_U32 u32ChanId, BSP_U32 cmd, BSP_VOID *param)
{
/*lint --e{701} */
u32 channel_id = 0;
s32 ret = ICC_OK;
if ((u32ChanId >= UDI_ICC_GUOM0 ) && (u32ChanId <= UDI_ICC_GUOM5))
{
u32ChanId = u32ChanId - UDI_ICC_GUOM0 + ICC_CHN_GUOM0;
}
channel_id = ((u16)u32ChanId << 16 | (u16)ICC_DEFAULT_SUB_CHANNEL);/* [false alarm]:屏蔽Fortify错误 */
if(u32ChanId >= ICC_CHN_ID_MAX)
{
icc_print_error("invalid param[%d].\n", u32ChanId);
return ICC_INVALID_PARA;
}
switch(cmd)
{
case ICC_IOCTL_SET_READ_CB:
{
ret = (s32)bsp_icc_event_register(channel_id, icc_read_cb_wraper ,(void*)param, NULL, NULL);
break;
}
case ICC_IOCTL_SET_WRITE_CB:
{
ret = (s32)bsp_icc_event_register(channel_id, NULL, NULL, icc_write_cb_wraper ,(void*)param);
break;
}
case ICC_IOCTL_GET_STATE:
{
ret = (s32)bsp_icc_channel_status_get((u32)u32ChanId, (u32*)param);
break;
}
case ICC_IOCTL_SET_EVENT_CB:
{
break;
}
default:
{
icc_print_error("channel[%d] invalid cmd[%d].\n", u32ChanId, cmd);
ret = ICC_INVALID_PARA;
break;
}
}
return ret;
}
/********************************************************
*函数名 : Mbb_Common_Probe
*函数功能 :
*输入参数 : struct platform_device *dev
*输出参数 : 无
*返回值 : 执行成功返回0，失败返回非0值
*修改历史 :
* 2013-11-25 徐超 初版作成
********************************************************/
static int Mbb_Common_Probe(struct platform_device *dev)
{
int ret = 0;
#if ( FEATURE_ON == MBB_MLOG )
u32 channel_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_MLOG; /* 用于接收C核的mobile log消息 */
#endif
printk(KERN_ERR "\r\n [Mbb Common Drv] Mbb_Common_Probe!\n");
if(NULL == dev )
{
printk(KERN_ERR "\r\n [Mbb Common Drv]Mbb_Common_Probe: dev is NULL!\r\n");
return -1;
}
#if ( FEATURE_ON == MBB_MLOG )
/* 注册用于接收C核的mobile log消息的函数 */
ret = bsp_icc_event_register(channel_id, (read_cb_func)mbb_common_mlog_recv, NULL, NULL, NULL);
if(ret != 0)
{
printk(KERN_ERR "\r\n [Mbb Common Drv] bsp_icc_event_register error，ret=%d.\n", ret);
}
#endif
return ret;
}
/*
* Function : bsp_sc_init
* 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 :
*/
s32 bsp_sc_init(void)
{
u32 ret = 0;
memset(&g_sc_stat,0,sizeof(sc_status_stru));
/* sem create */
osl_sem_init(0,&g_sc_stat.sc_api_sem);
osl_sem_init(0,&g_sc_stat.sc_tsk_sem);
/* task create */
#ifdef __OS_VXWORKS__
ret = (u32)osl_task_init("sc_ccore_task",128,4096,(OSL_TASK_FUNC)sc_icc_task,NULL,(void*)&g_sc_stat.sc_taskid);
#elif defined(__OS_RTOSCK__)
ret = (u32)osl_task_init("sc_ccore_task",57,4096,(OSL_TASK_FUNC)sc_icc_task,NULL,(void*)&g_sc_stat.sc_taskid);
#endif
if(ret)
{
sc_error_printf("init task failed!\n");
return BSP_ERR_SC_TASK_INIT_FAIL;
}
/* register icc event */
if(ICC_OK!=bsp_icc_event_register(SC_ICC_CHAN_ID, sc_icc_msg_proc,NULL,NULL,NULL))
{
sc_error_printf("register icc channel failed!\n");
return BSP_ERR_SC_SEM_INIT_FAIL;
}
sc_printf("[SC]: init success.\n");
return SC_OK;
}
int efuse_init(void)
{
int ret;
u32 chan_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_EFUSE;
if(1 == is_efuse_init)
{
return EFUSE_OK;
}
osl_sem_init(0, &efuse_sem_id);
osl_sem_init(1, &efuse_queue_sem_id);
ret = bsp_icc_event_register(chan_id, (read_cb_func)bsp_efuse_data_receive, NULL, NULL, NULL);/* [false alarm]:屏蔽Fortify错误 */
if(ICC_OK != ret)
{
efuse_print_error("register is error.\n");
return EFUSE_ERROR;
}
is_efuse_init = 1;/* [false alarm]:屏蔽Fortify错误 */
efuse_print_info("efuse init ok.\n");
return EFUSE_OK;
}
/*****************************************************************************
* 函 数 名 :bsp_temperature_init
*
* 功能描述 : 温度保护核间通信，A核初始化函数
*
* 输入参数 : 无
* 输出参数 : 无
*
* 返 回 值 : TEMPERATURE_OK: 操作成功
* TEMPERATURE_ERROR: 操作失败
*
* 其它说明 : 无
*
*****************************************************************************/
static int __init bsp_temperature_init(void)
{
int ret = 0;
u32 chan_id = ICC_CHN_MCORE_ACORE << 16 | MCORE_ACORE_FUNC_TEMPERATURE;
//printk("acore tem time %d.\n", bsp_get_elapse_ms());
/*从NV里面获取温保基本信息保存到共享内存*/
if(0 != tem_protect_nv_config())
{
tem_print_error(" tem_protect_nv_config is fail.\n");
return TEMPERATURE_ERROR;
}
ret = bsp_icc_event_register(chan_id, (read_cb_func)bsp_tem_data_receive, NULL, NULL, NULL);
if(0 != ret)
{
tem_print_error("register is error, %d.\n", ret);
return TEMPERATURE_ERROR;
}
tem_print_info("temperature init is ok.\n");
return TEMPERATURE_OK;
}
/*
* init icc channel used by nv module
*/
u32 nv_icc_chan_init(void)
{
u32 chanid = 0;
chanid = ICC_CHN_MCORE_ACORE << 16 | NV_RECV_FUNC_AM;
return (u32)bsp_icc_event_register(chanid,nv_icc_msg_proc,NULL,NULL,NULL);
}
int bsp_dual_modem_init(void)
{
int ret = ERROR;
DRV_DUAL_MODEM_STR dual_modem_nv;
DRV_DM_UART5_STR uart_cfg_nv;
memset_s((void*)&g_dual_modem_ctrl.uart_port, sizeof(g_dual_modem_ctrl.uart_port), 0, sizeof(g_dual_modem_ctrl.uart_port)); /*lint !e545*/ //初始化串口属性
memset_s((void*)&dual_modem_nv, sizeof(DRV_DUAL_MODEM_STR), 0, sizeof(DRV_DUAL_MODEM_STR));
memset_s((void*)&uart_cfg_nv, sizeof(DRV_DM_UART5_STR), 0, sizeof(DRV_DM_UART5_STR));
ret = bsp_nvm_read(NV_ID_DRV_DUAL_MODEM ,(u8 *)&dual_modem_nv ,sizeof(DRV_DUAL_MODEM_STR));
if (ret != OK)
{
dm_print_err("read dual modem nv fail: %d\n", NV_ID_DRV_DUAL_MODEM);
dual_modem_nv.enUartEnableCfg = DUAl_MODEM_DISABLE;
}
if(DUAl_MODEM_ENABLE == dual_modem_nv.enUartEnableCfg)
{
ret = bsp_nvm_read(NV_ID_DRV_DM_UART5_CFG ,(u8 *)&uart_cfg_nv ,sizeof(DRV_DM_UART5_STR));
if (ret != OK)
{
dm_print_err("read dual modem nv fail: %d\n", NV_ID_DRV_DM_UART5_CFG);
uart_cfg_nv.ex1_param = 0;
}
g_dual_modem_ctrl.uart_port.rts_mask = (uart_cfg_nv.ex1_param << 14);
if(DUAl_MODEM_ENABLE == dual_modem_nv.enUartlogEnableCfg)
{
g_dual_modem_ctrl.log_flag = 1;
bsp_mod_level_set(BSP_MODU_DUAL_MODEM ,BSP_LOG_LEVEL_DEBUG);
}
ret = dual_modem_wakeup_init(dual_modem_nv);
if(ret !=OK)
{
dm_print_err("dual modem wakeup init failed!\n");
return ERROR;
}
if(OK != dual_modem_dump_init())
{
dm_print_err("dual_modem_dump_init fail!\n");
return ERROR;
}
#ifdef LPM3_GPIO
/* 注册ICC读写回调 */
if(OK != bsp_icc_event_register((ICC_CHN_MCORE_CCORE << 16)|MCORE_CCORE_FUNC_UART,
recv_lpm3_msg_icc_cb , NULL, NULL, NULL))
{
dm_print_err("register icc callback fail\n");
return ERROR;
}
#endif
g_dual_modem_ctrl.nv_flag = DUAl_MODEM_ENABLE;
dm_print_err("dual modem init\n");
}
return OK;
}
BSP_S32 BSP_ICC_Ioctl(BSP_U32 u32ChanId, BSP_U32 cmd, BSP_VOID *param)
{
u32 func_id = ICC_DEFAULT_SUB_CHANNEL;
u32 channel_id = u32ChanId << 16 | func_id;
s32 ret = ICC_OK;
if(u32ChanId >= ICC_CHN_ID_MAX)
{
icc_print_error("invalid param[%d].\n", u32ChanId);
return BSP_ERR_ICC_INVALID_PARAM;
}
switch(cmd)
{
case ICC_IOCTL_SET_READ_CB:
{
ret = (s32)bsp_icc_event_register(channel_id, icc_read_cb_wraper ,(void*)param, NULL, NULL);
break;
}
case ICC_IOCTL_SET_WRITE_CB:
{
ret = (s32)bsp_icc_event_register(channel_id, NULL, NULL, icc_write_cb_wraper ,(void*)param);
break;
}
case ICC_IOCTL_GET_STATE:
{
ret = (s32)bsp_icc_channel_status_get((u32)u32ChanId, (u32*)param);
break;
}
case ICC_IOCTL_SET_EVENT_CB:
{
break;
}
default:
{
icc_print_error("channel[%d] invalid cmd[%d].\n", u32ChanId, cmd);
ret = BSP_ERR_ICC_INVALID_PARAM;
break;
}
}
return ret;
}
int BSP_ICC_Open(unsigned int u32ChanId, ICC_CHAN_ATTR_S *pChanAttr)
{
u32 channel_id = 0;
u32 channel_index = 0;
struct bsp_icc_cb_info *pICC_cb_info;
if (icc_channel_logic2phy(u32ChanId, &channel_id))
{
icc_print_error("icc_channel_logic2phy err logic id 0x%x\n", u32ChanId);
goto out; /*lint !e801 */
}
channel_index = channel_id >> 16;
if ((ICC_CHN_ID_MAX <= channel_index) || (!g_icc_ctrl.channels[channel_index]))
{
icc_print_error("invalid channel_index[%d]\n", channel_index);
goto out; /*lint !e801 */
}
/* coverity[REVERSE_INULL] */
if(!pChanAttr)
{
icc_print_error("pChanAttr is null!\n");
goto out; /*lint !e801 */
}
else if(pChanAttr->u32FIFOOutSize != pChanAttr->u32FIFOInSize)
{
icc_print_error("invalid param u32ChanId[%d],pChanAttr[0x%p],fifo_in[0x%x],fifo_out[0x%x]\n",
channel_index, pChanAttr, pChanAttr->u32FIFOInSize, pChanAttr->u32FIFOOutSize);
goto out; /*lint !e801 */
}
if(pChanAttr->u32FIFOInSize > g_icc_ctrl.channels[channel_index]->fifo_send->size)/*lint !e574 */
{
icc_print_error("channel_id 0x%x user fifo_size(0x%x) > fifo_size(0x%x) defined in icc\n",
channel_id,
pChanAttr->u32FIFOInSize, g_icc_ctrl.channels[channel_index]->fifo_send->size);
goto out; /*lint !e801 */
}
pICC_cb_info = osl_malloc(sizeof(struct bsp_icc_cb_info));
if (pICC_cb_info == NULL) {
icc_print_error("Fail to malloc memory \n");
return ICC_MALLOC_MEM_FAIL;
}
pICC_cb_info->read_cb = pChanAttr->read_cb;
pICC_cb_info->channel = u32ChanId;
/* coverity[leaked_storage] */
return (BSP_S32)bsp_icc_event_register(channel_id, icc_read_cb_wraper, pICC_cb_info, icc_write_cb_wraper, (void*)pChanAttr->write_cb);
out:
return ICC_INVALID_PARA;
}
static void register_icc_for_cpufreq(void)
{
s32 ret;
u32 channel_id_set = ICC_CHN_MCORE_CCORE << 16 | MCU_CCORE_CPUFREQ;
ret = bsp_icc_event_register(channel_id_set, (read_cb_func)balong_cpufreq_cb_getprofile, (void *)NULL, (write_cb_func)NULL, (void *)NULL);
if (ret != BSP_OK)
{
cpufreq_err("icc register failed %d\n", ret);
}
cpufreq_info("register icc %d\n", ret);
}
static void cpufreq_icc_init(void)
{
s32 ret;
u32 channel_id_set = 0;
/* m3 acore icc */
channel_id_set = (ICC_CHN_MCORE_ACORE << 16) | MCU_ACORE_CPUFREQ;
ret = bsp_icc_event_register(channel_id_set, cpufreq_icc_read_cb, NULL, (write_cb_func)NULL, (void *)NULL);
if(ret != ICC_OK)
{
M3CPUFREQ_PRINT("iccinit 1 error\n");
}
channel_id_set = (ICC_CHN_MCORE_CCORE << 16) | MCU_CCORE_CPUFREQ;
ret = bsp_icc_event_register(channel_id_set, cpufreq_icc_read_cb, NULL, (write_cb_func)NULL, (void *)NULL);
if(ret != ICC_OK)
{
M3CPUFREQ_PRINT("iccinit 2 error\n");
}
}
/*****************************************************************************
函 数 名 : his_boot_probe
功能描述 : power on
输入参数 :
输出参数 : 无
返 回 值 :
调用函数 :
被调函数 :
*****************************************************************************/
static int __init his_boot_probe(struct platform_device *pdev)
{
int rt;
u32 channel_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_ONOFF;
#ifndef HI_ONOFF_PHONE
/* get early param */
/* 清除reboot flag */
power_on_reboot_flag_set(POWER_OFF_REASON_INVALID);
/* normal模式下 clear misc partition */
if(NORMAL_CHARGING_MODE == get_pd_charge_flag()){
rt = clear_misc_message();
if(rt < 0){
pr_dbg("clear misc message failed.\n");
return rt;
}
}
/* get power on reason */
power_on_reason_get();
/* get power time */
power_on_time_get();
/* sysfs create */
power_on_init_attrs();
rt = (int)sysfs_create_group(&pdev->dev.kobj, &his_boot_group);
if (rt < 0)
{
pr_dbg("create sys filesystem node failed.\n");
return rt;
}
/* file create and power on info record */
rt = power_on_log_save();
if(rt < 0){
pr_dbg("power on log record failed.\n");
return rt;
}
#endif
#if 0 /* #ifdef FEATURE_E5_ONOFF */
/* 创建开机timer */
power_on_timer_init();
#endif
rt = bsp_icc_event_register(channel_id, (read_cb_func)bsp_power_ctrl_read_cb, NULL, NULL, NULL);
if(rt != 0){
pr_dbg("icc event register failed.\n");
}
return rt;
}
/*****************************************************************************
* 函 数 名 : socp_icc_chan_init
*
* 功能描述 : icc通道初始化
*
* 输入参数 : 无
*
* 输出参数 : 无
*
* 返 回 值 : 释放成功与否的标识码
*****************************************************************************/
s32 socp_icc_chan_init(void)
{
u32 chan_id;
chan_id = (ICC_CHN_MCORE_CCORE << 16) | MCORE_CCORE_FUNC_SOCP;
if(ICC_OK != bsp_icc_event_register(chan_id, socp_icc_read_cb, NULL, (write_cb_func)NULL, (void *)NULL))
{
return BSP_ERROR;
}
return BSP_OK;
}
void register_icc_for_cpufreq(void)
{
s32 ret;
u32 channel_id_set = ICC_CHN_MCORE_ACORE << 16 | MCU_ACORE_CPUFREQ;
ret = bsp_icc_event_register(channel_id_set, (read_cb_func)balong_cpufreq_cb_getprofile, (void *)NULL, (write_cb_func)NULL, (void *)NULL);
if (ret != BSP_OK)
{
cpufreq_err("icc register failed %d\n", ret);
}
else
{
;
}
cpufreq_debug("register icc to mcore %d\n", ret);
}/*lint !e533 */
BSP_S32 BSP_ICC_Open(BSP_U32 u32ChanId, ICC_CHAN_ATTR_S *pChanAttr)
{
u32 func_id = ICC_DEFAULT_SUB_CHANNEL; /* 除ifc通道外，其他通道只有一个回调 */
u32 channel_id = u32ChanId << 16 | func_id;
u32 i = 0;
u32 real_channel_size = bsp_icc_channel_size_get();
/* coverity[REVERSE_INULL] */
if(!pChanAttr)
{
icc_print_error("pChanAttr is null!\n");
goto out;
}
else if(pChanAttr->u32FIFOOutSize != pChanAttr->u32FIFOInSize || u32ChanId >= ICC_CHN_ID_MAX)
{
icc_print_error("invalid param u32ChanId[%d],pChanAttr[%p],fifo_in[0x%x],fifo_out[0x%x]\n",
u32ChanId, pChanAttr, pChanAttr->u32FIFOInSize, pChanAttr->u32FIFOOutSize);
goto out;
}
for(i = 0; i < real_channel_size; i++)
{
if(u32ChanId == g_icc_init_info[i].real_channel_id)
{
break;
}
}
if(i >= real_channel_size)
{
icc_print_error("channel_id[%d] cannot find in g_icc_init_info array\n", u32ChanId);
goto out;
}
else
{
if(pChanAttr->u32FIFOInSize > g_icc_init_info[i].fifo_size)/*lint !e574 */
{
icc_print_error("user fifo_size(%d) > fifo_size(%d) defined in bsp(g_icc_init_info)\n",
pChanAttr->u32FIFOInSize, g_icc_init_info[i].fifo_size);
goto out;
}
}
return (BSP_S32)bsp_icc_event_register(channel_id, icc_read_cb_wraper, (void*)pChanAttr->read_cb, icc_write_cb_wraper, (void*)pChanAttr->write_cb);
out:
return BSP_ERR_ICC_INVALID_PARAM;
}
static int bsp_hkadc_acore_init(void)
{
int ret = 0;
u32 icc_channel_id = ICC_CHN_MCORE_ACORE << 16 | MCORE_CCORE_FUNC_HKADC;
osl_sem_init(1, &g_hkadc_icc_sem_id);
osl_sem_init(0, &g_hkadc_value_sem_id);
ret |= bsp_icc_event_register(icc_channel_id,
(read_cb_func)bsp_hkadc_icc_callback, NULL, NULL, NULL);
if (ret)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_HKADC, "hkadc init error, error code: 0x%x\r\n", ret);
}
return ret;
}
static s32 __devinit balong_rtc_probe(struct platform_device *pdev)
{
struct rtc_device *balongv7r2_rtc;
u32 channel_id_set = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_RTC_SETTIME;
s32 ret = 0;
balongv7r2_rtc = rtc_device_register("balongv7r2_rtc", &pdev->dev, &balong_rtc_ops,
THIS_MODULE);
if (IS_ERR(balongv7r2_rtc))
{
ret = PTR_ERR(balongv7r2_rtc);
goto cleanup0;
}
platform_set_drvdata(pdev, balongv7r2_rtc);
/* 清中断 */
readl(g_rtc_ctrl.rtc_base_addr + HI_RTC_EOI_OFFSET);
/*disable the alarm interupt */
writel( 0, g_rtc_ctrl.rtc_base_addr + HI_RTC_CCR_OFFSET);
ret = request_irq(RTC_INT_ID, (irq_handler_t)balong_rtc_alarmhandler, IRQF_DISABLED, "balongv7r2_rtc", (void *)balongv7r2_rtc);
if (ret != 0)
goto cleanup1;
ret = bsp_icc_event_register(channel_id_set, (read_cb_func)balong_rtc_cb_settime, (void *)NULL, (write_cb_func)NULL, (void *)NULL);
if(0 != ret)
goto cleanup2;
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_RTC,"RTC init OK!\r\n");
return BSP_OK;
cleanup2:
rtc_print_error("rtc register icc fail\r\n");
rtc_device_unregister(balongv7r2_rtc);
free_irq(RTC_INT_ID, balongv7r2_rtc);
balongv7r2_rtc = NULL;
cleanup1:
rtc_print_error("rtc request_irq fail\r\n");
rtc_device_unregister(balongv7r2_rtc);
balongv7r2_rtc = NULL;
cleanup0:
rtc_print_error("rtc device register fail\r\n");
balongv7r2_rtc = NULL;
/*lint -save -e438*/
return ret;
/*lint -restore*/
}
/*lint -save -e745*/
int socp_debug_init(void)
{
u32 channel_id = ICC_CHN_ACORE_CCORE_MIN <<16 | IFC_RECV_FUNC_SOCP_DEBUG;
osl_sem_init(0, &g_stSocpDebugCtrl.task_sem);
#if defined(__KERNEL__)
if(NULL == proc_create("socpProc", 0660, NULL, &g_strSocpProc))
{
return -1;
}
#endif
(void)osl_task_init("socpProc",30, 1024, (OSL_TASK_FUNC)socp_debug_icc_task,NULL, &g_stSocpDebugCtrl.task_id);
(void)bsp_icc_event_register(channel_id, (read_cb_func)socp_debug_icc_msg_callback,NULL,NULL,NULL);
return 0;
}
static int __init hi_efuse_comm_init(void)
{
int ret = 0;
u32 chan_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_EFUSE;
INIT_WORK(&efuse_work, efuse_handle_work);
ret = bsp_icc_event_register(chan_id, (read_cb_func)bsp_efuse_data_receive, NULL, NULL, NULL);
if(0 != ret)
{
efuse_print_error("efuse icc register is error.\n");
return EFUSE_ERROR;
}
efuse_print_info("efuse comm init ok.\n");
return EFUSE_OK;
}
/*****************************************************************************
函 数 名 : bsp_loadps_ccore_init
功能描述 : loadps的C核的初始化函数
输入参数 : 无
输出参数 : 成功返回0，失败返回非0
*****************************************************************************/
s32 bsp_loadps_ccore_init(void)
{
s32 ret = 0;
struct ovly_addr_info *pOvly_addr_info;
/*设置一下loadps模块的打印级别函数*/
bsp_mod_level_set(BSP_MODU_LOADPS,BSP_LOADPS_LOG_LEVEL);
loadps_trace(BSP_LOG_LEVEL_INFO ,"bsp_loadps_ccore_init start\n");
osl_sem_init ( 1, &loadps_mutex);
osl_sem_init ( 0, &loadps_wait_complete_mutex);
pOvly_addr_info = _ovly_table;
(void)memset_s((void *)pOvly_addr_info->addr, pOvly_addr_info->size, 0x0, pOvly_addr_info->size);
(void)memset_s((void *)&g_loadps_debuginfo, sizeof (loadps_debuginfo), 0x0, sizeof (loadps_debuginfo));
ret = bsp_icc_event_register (LOADPS_ICC_IFC_ID, bsp_loadps_ccore_callback, NULL, NULL, NULL );
if ( ret )
{
loadps_trace(BSP_LOG_LEVEL_ERROR ,"bsp_icc_event_register error, ret = 0x%x\n", ret);
return ret;
}
loadps_trace(BSP_LOG_LEVEL_INFO ,"bsp_loadps_ccore_init complete\n");
return ret;
}
s32 bsp_rfile_init(void)
{
s32 ret;
g_stRfileMain.semAll = osSemaphoreCreate(osSemaphore(rfile_all_sem), 1);
g_stRfileMain.semReq = osSemaphoreCreate(osSemaphore(rfile_req_sem), 0);
ret = bsp_icc_event_register(RFILE_MCORE_ICC_RD_CHAN, bsp_RfileCallback, NULL, NULL, NULL);
if(ret)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_RFILE, "[%s] bsp_icc_event_register failed.\n", __FUNCTION__);
return BSP_ERROR;
}
g_stRfileMain.bInitFlag = BSP_TRUE;
// bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_RFILE, "[%s] success.\n", __FUNCTION__);
return BSP_OK;
}
/*****************************************************************************
函 数 名 : bsp_on_off_init
功能描述 : C核开关机初始化
输入参数 :
输出参数 : 无
返 回 值 :
调用函数 :
被调函数 :
*****************************************************************************/
int bsp_on_off_init( void )
{
int ret = 0;
u32 icc_channel_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_ONOFF;
memset((void*)&g_pwrctrl,0,sizeof(g_pwrctrl));
osl_sem_init(1, &(g_pwrctrl.pwr_sem));
osl_sem_init(0, &g_sem_mode);
ret |= bsp_icc_event_register(icc_channel_id,
(read_cb_func)bsp_on_off_icc_callback, NULL, NULL, NULL);
if (ret)
{
bsp_trace(BSP_LOG_LEVEL_ERROR, BSP_MODU_ONOFF, "onoff init error, error code: 0x%x\r\n", ret);
}
g_pwrctrl.is_init = 1;
return ret;
}
/*****************************************************************************
函 数 名 : pastar_adp_init
功能描述 : pastar 适配层初始化
输入参数 : 无
输出参数 : 无
返 回 值 : 0 - 成功; else - 失败
*****************************************************************************/
s32 pastar_adp_init(void)
{
s32 ret = ERROR;
pastar_print_info("Execuing ...");
/* icc register */
ret = bsp_icc_event_register(PASTAR_ICC_CHN_ID, pastar_notify_exception, NULL, NULL, NULL);
if(ret != OK)
{
pastar_print_error("icc register failed, ret = %d\n", ret);
return ret;
}
/* dclient register */
if(!pastar_dclient)
{
pastar_dclient = dsm_register_client(&dsm_pastar);
if(!pastar_dclient)
{
pastar_print_error("dsm_register_client failed\n");
return ERROR;
}
}
/* create work queue */
pastar_dsm_wq = create_singlethread_workqueue("pastar_dsm_wq");
if (IS_ERR(pastar_dsm_wq))
{
pastar_print_error("create workqueue failed\n");
return ERROR;
}
INIT_WORK(&pastar_dsm_work, pastar_dsm_work_func);
pastar_print_always("PAStar init OK\n");
/* success */
return OK;
}
/*
* Function : bsp_sc_kernel_init
* 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 :
*/
s32 bsp_sc_kernel_init(void)
{
s32 ret = SC_ERROR;
osl_sem_init(0,&g_sc_stat.sc_tsk_sem);
ret = osl_task_init("sc_acore_task",15,1024,sc_icc_task,NULL,(void*)&g_sc_stat.sc_taskid);
if(ret)
{
sc_error_printf("init task failed!\n");
return BSP_ERR_SC_TASK_INIT_FAIL;
}
if(ICC_OK != bsp_icc_event_register(SC_ICC_CHAN_ID, sc_icc_msg_proc,NULL,NULL,NULL))
{
sc_error_printf("register icc channel failed!\n");
return BSP_ERR_SC_SEM_INIT_FAIL ;
}
sc_printf("[SC]: init success.\n");
return SC_OK;
}
s32 bsp_icc_test_init(void)
{
u32 i = 0;
s32 ret = ICC_OK;
if(ICC_TEST_CASE_INITILIZED == g_icc_test.state)
{
icc_print_error("icc_test has intilized\n");
return ICC_OK;
}
memset(&g_icc_test, 0, sizeof(g_icc_test)); /*lint !e665 */
icc_print_debug("icc_test initilizing\n");
for(i = 0; i < ICC_VALIDE_CHN_NUM; i++)
{
ret = icc_test_channel_reinit(g_icc_init_info[i].real_channel_id, ICC_TEST_CHANNEL_SIZE);
if(ICC_OK != ret)
{
icc_print_error("icc_test_channel_reinit error\n");
return ICC_ERR;
}
ret = icc_test_sub_chn_init(g_icc_init_info[i].real_channel_id, ICC_TEST_CHANNEL_SIZE/2, ICC_TEST_CHANNEL_START);
if(ICC_OK != ret)
{
icc_print_error("icc_test_sub_chn_init error\n");
return ICC_ERR;
}
}
#ifdef ICC_HAS_DEBUG_FEATURE
/* 测试打开打印开关 */
icc_dbg_print_sw(0);
#endif
ret = icc_test_channel_reinit(ICC_CHN_CSHELL, SUPPORT_ICC_READ_IN_OTHER_TASK);
if(ICC_OK != ret)
{
icc_print_error("cshell_channel_reinit error\n");
return ICC_ERR;
}
ret = icc_test_sub_chn_init(ICC_CHN_CSHELL, SUPPORT_ICC_READ_IN_OTHER_TASK, 0);
if(ICC_OK != ret)
{
icc_print_error("cshell_test_sub_chn_init error\n");
return ICC_ERR;
}
bsp_icc_event_unregister(ICC_CHN_CSHELL << 16 | 0);
bsp_icc_event_unregister(ICC_CHN_CSHELL << 16 | 1);
bsp_icc_event_unregister(ICC_CHN_CSHELL << 16 | 2);
bsp_icc_event_register(ICC_CHN_CSHELL << 16 | 0, (read_cb_func)icc_send_test_cb0_new, NULL, NULL, NULL);
bsp_icc_event_register(ICC_CHN_CSHELL << 16 | 1, (read_cb_func)icc_send_test_cb1_new, NULL, NULL, NULL);
bsp_icc_event_register(ICC_CHN_CSHELL << 16 | 2, (read_cb_func)icc_send_test_cb2_new, NULL, NULL, NULL);
osl_sem_init(ICC_SEM_EMPTY, &g_icc_test.recv_task_sem); /*lint !e40 */
g_icc_test.recv_task_flag = 1;
if(ICC_ERR == osl_task_init("icc_read_test", ICC_TEST_TASK_PRI+1, ICC_TASK_STK_SIZE,
(task_entry)icc_read_task_entry, (void *)(ICC_CHN_CSHELL << 16 | 2), (u32 *)&g_icc_test.recv_task_id))
{
icc_print_error("create icc_read_test task error\n");
return ICC_ERR;
}
icc_debug_init(bsp_icc_channel_size_get());
/* 状态最后更新 */
g_icc_test.state = ICC_TEST_CASE_INITILIZED;
return ICC_OK;
}
/*****************************************************************************
* 函 数 名 : cshell_init
*
* 功能描述 : cshell初始化
*
* 输入参数 : void
* 输出参数 : 无
*
* 返 回 值 : 无
*
* 修改记录 :
*****************************************************************************/
int cshell_init(void)
{
SHELL_IO_CHAN *ptr_shell = &shell_io_channel;
int ret = 0;
DRV_UART_SHELL_FLAG uartcshell_nv = {.extendedbits = 0};
ptr_shell->cshell_send_permission = 0;
if(bsp_nvm_read(NV_ID_DRV_UART_SHELL_FLAG, (u8 *)&uartcshell_nv, sizeof(DRV_UART_SHELL_FLAG)))
{
printk("[A:CSHELL]:bsp_nvm_read fails line:%d uartcshell_nv.cshell_to_auart:%d\n", __LINE__, uartcshell_nv.extendedbits);
}
if(uartcshell_nv.extendedbits & 0x1U)
{
ptr_shell->cshell_send_permission = (s32)((unsigned int)(ptr_shell->cshell_send_permission) | (0x1U << 2));
}
if (CSHELL_OK != cshell_sio_init(ptr_shell))
{
cshell_print_error("io init fail!\n");
return CSHELL_ERROR;
}
/* 注册ICC读写回调 */
ptr_shell->icc_channel_id = (ICC_CHN_CSHELL << 16 | 0);
if(CSHELL_OK !=bsp_icc_event_register(ptr_shell->icc_channel_id, (read_cb_func)cshell_read_cb , NULL, NULL, NULL))
{
cshell_print_error("register icc callback fail!\n");
return CSHELL_ERROR;
}
/* 改变CSHELL 到USB 虚拟串口*/
if(readl((u32)SHM_MEM_CHSELL_FLAG_ADDR) == PRT_FLAG_EN_MAGIC_M)
ret = cshell_direction(CSHELL_MODE_USB);
else
ret = cshell_direction(CSHELL_MODE_UART);
if (OK != ret)
{
cshell_print_error("direct cshell to usb fail\n");
return CSHELL_ERROR;
}
/* 禁止串口中断,M核心采用UART */
//intDisable(sram->UART_INFORMATION[1].interrupt_num);
memset((void *)&g_cshell_dbg, 0, sizeof(g_cshell_dbg));
if(CSHELL_OK != bsp_icc_event_register((ICC_CHN_IFC << 16)|IFC_RECV_FUNC_CSHELL, cshell_command_cb, NULL, NULL, NULL))
{
cshell_print_error("register icc callback fail!\n");
return CSHELL_ERROR;
}
g_cshell_dbg.state = 1;
printf("ok\n");
return CSHELL_OK;
}
void cshell_dbg_print_sw(int sw)
{
g_cshell_dbg.print_sw = sw;
}
void cshell_debug_show(void)
{
printf("*****************************************************\n");
printf("g_cshell_dbg.state : 0x%08x\n", g_cshell_dbg.state);
printf("g_cshell_dbg.print_sw : 0x%08x\n", g_cshell_dbg.print_sw);
printf("g_cshell_dbg.lost_data_cnt: 0x%08x\n", g_cshell_dbg.lost_data_cnt);
printf("g_cshell_dbg.recv_data_cnt: 0x%08x\n", g_cshell_dbg.recv_data_cnt);
printf("g_cshell_dbg.send_succ_cnt: 0x%08x\n", g_cshell_dbg.send_succ_cnt);
printf("g_cshell_dbg.send_busy_cnt: 0x%08x\n", g_cshell_dbg.send_busy_cnt);
printf("g_cshell_dbg.send_fail_cnt: 0x%08x\n", g_cshell_dbg.send_fail_cnt);
}
/*******************************************************************************
* 函 数 名 : cshell_init
*
* 功能描述 : cshell初始化接口
*
* 输入参数 : 无
*
* 输出参数 : 无
*
* 返 回 值 : CSHELL_ERROR-初始化失败，CSHELL_OK-初始化成功
*
*******************************************************************************/
int cshell_init(void)
{
cshell_ctx_t *cshell_ctx = &g_cshell_ctx;
DRV_UART_SHELL_FLAG uartcshell_nv = {.extendedbits = 0};
u32 channel_id = 0;
printk("A:cshell_init start \n");
cshell_ctx->ccshell_work_flg = 1;
cshell_ctx->cshell_acm_fd = 0;
cshell_ctx->usb_send_buf = (u8*)kmalloc(CSHELL_BUFFER_SIZE, GFP_KERNEL);
if(!cshell_ctx->usb_send_buf)
{
printk("[ACSHELL]kmalloc fails line:%d", __LINE__);
goto error;
}
cshell_ctx->usb_send_buf_size = CSHELL_BUFFER_SIZE;
cshell_ctx->usb_send_buf_r = 0;
cshell_ctx->usb_send_buf_w = 0;
cshell_icc_init();
sema_init(&(cshell_ctx->cshell_send_sem), 0);
sema_init(&(cshell_ctx->cshell_recv_sem), 0);
sema_init(&(cshell_ctx->cshell_usb_send_sem), 0);
spin_lock_init(&g_cshell_ctx.cshell_spin_loc_permit);
if(bsp_nvm_read(NV_ID_DRV_UART_SHELL_FLAG, (u8 *)&uartcshell_nv, sizeof(DRV_UART_SHELL_FLAG)))
{
printk("[A:CSHELL]:bsp_nvm_read fails line:%d uartcshell_nv.cshell_to_auart:%d\n", __LINE__, uartcshell_nv.extendedbits);
}
if(uartcshell_nv.extendedbits & 0x1U)
{
cshell_set_bit(AUART_CSHELL);
}else{
cshell_clear_bit(AUART_CSHELL);
}
printk("A :icc channel[%d] open sucess \n", ICC_CHN_CSHELL);
channel_id = cshell_ctx->icc_channel_id << 16;
if(bsp_icc_event_register(channel_id ,cshell_read_cb, NULL, NULL, NULL))
printk(KERN_ERR "A:CSHELL bsp_icc_event_register fail");
cshell_ctx->send_task = kthread_run(cshell_send_thread, NULL, "cshell_send_thread");
if (IS_ERR(cshell_ctx->send_task))
{
printk("A:cshell_init send thread create fail\n");
goto error;
}
cshell_ctx->recv_task = kthread_run(cshell_recv_thread, NULL, "cshell_recv_thread");
if (IS_ERR(cshell_ctx->recv_task))
{
printk("A:cshell_init recv thread create fail\n");
goto error;
}
cshell_ctx->send_task_usb = kthread_run(cshell_usb_send_thread, NULL, "cshell_usb_send_thread");
if (IS_ERR(cshell_ctx->recv_task))
{
printk("[ACSHELL] fail to create cshell_usb_send_thread\n");
goto error;
}
printk("A:cshell_init udi cb register\n");
/* 注册USB插入回调函数*/
bsp_usb_register_enablecb(cshell_udi_open_cb);
bsp_usb_register_disablecb(cshell_udi_close_cb);
cshell_ctx->valid = 1;
printk("A:cshell_init ok\n");
return CSHELL_OK;
error:
cshell_uninit();
printk("A:cshell_init fail...\n");
return CSHELL_ERROR;
}
//#ifndef OS_ANDROID_USE_K3V3_KERNEL
module_init(cshell_init);
//#endif
#ifdef __cplusplus
}
/*****************************************************************************
函 数 名 : his_boot_probe
功能描述 : power on
输入参数 :
输出参数 : 无
返 回 值 :
调用函数 :
被调函数 :
*****************************************************************************/
static int __init his_boot_probe(struct platform_device *pdev)
{
int rt;
u32 channel_id = ICC_CHN_IFC << 16 | IFC_RECV_FUNC_ONOFF;
#if ( FEATURE_ON == MBB_MLOG )
if (*(u32*)SRAM_ABNORMAL_REBOOT_ADDR == SRAM_ABNORAL_REBOOT_NUM)
{
mlog_print(MLOG_POWER, mlog_lv_info, "reboot flag POWER_OFF_REASON_CRASH\n");
mlog_set_statis_info("abnormal_reboot_times",1);
}
*(u32*)SRAM_ABNORMAL_REBOOT_ADDR = SRAM_ABNORAL_REBOOT_CLEAR;
#endif
#ifndef HI_ONOFF_PHONE
/* get early param */
/* 清除reboot flag */
power_on_reboot_flag_set(POWER_OFF_REASON_INVALID);
/* normal模式下 clear misc partition */
#if (FEATURE_ON == MBB_COMMON)
#if 0
if(NORMAL_CHARGING_MODE == get_pd_charge_flag()){
/*在misc分区存在的情况下，才进行清除操作*/
rt = mtd_partation_exist("misc");
if(rt){
printk("find misc partition\n");
rt = clear_misc_message();
if(rt < 0){
pr_dbg("clear misc message failed.\n");
return rt;
}
}
}
#endif
#else
if(NORMAL_CHARGING_MODE == get_pd_charge_flag()){
rt = clear_misc_message();
if(rt < 0){
pr_dbg("clear misc message failed.\n");
return rt;
}
}
#endif
#if (FEATURE_ON == MBB_COMMON)
power_on_mode_get();
#endif
/* get power on reason */
power_on_reason_get();
/* get power time */
power_on_time_get();
/* sysfs create */
power_on_init_attrs();
rt = (int)sysfs_create_group(&pdev->dev.kobj, &his_boot_group);
if (rt < 0)
{
pr_dbg("create sys filesystem node failed.\n");
return rt;
}
/* file create and power on info record */
rt = power_on_log_save();
if(rt < 0){
pr_dbg("power on log record failed.\n");
return rt;
}
#endif
#ifdef FEATURE_E5_ONOFF
/* 创建开机timer */
power_on_timer_init();
#endif
rt = bsp_icc_event_register(channel_id, (read_cb_func)bsp_power_ctrl_read_cb, NULL, NULL, NULL);
if(rt != 0){
pr_dbg("icc event register failed.\n");
}
return rt;
}
