int inputhub_mcu_connect( void )
{
int ret = 0;
//connect to inputhub_route
api_inputhub_mcu_recv=inputhub_route_recv_mcu_data;//should supply an interface
//connect to mcu
hwlog_info("----%s--->\n",__func__);
nb.next = NULL;
nb.notifier_call = mbox_recv_notifier;
/* register the rx notify callback */
ret = RPROC_MONITOR_REGISTER(HISI_RPROC_IOM3, &nb);
if (ret)
hwlog_info("%s:RPROC_MONITOR_REGISTER failed", __func__);
return 0;
}
static s32 bsp_ipc_probe(struct platform_device *dev)
{
s32 ret = 0,i = 0; /*lint !e34 */
u32 array_size=0;
k3_ipc_block.next = NULL;
k3_ipc_block.notifier_call = hisi_k3_lpm2ap_ipc_handler;
ret = RPROC_MONITOR_REGISTER(HISI_RPROC_LPM3, &k3_ipc_block);
if (ret) {
bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_IPC,"ipc monitor register Failed!\n");
return ERROR;
}
ipc_ctrl.core_num = IPC_CORE_ACORE;
for(i = 0;i< INTSRC_NUM;i++ )
{
ipc_ctrl.sem_exist[i] = false;
}
array_size = sizeof(struct ipc_entry)*INTSRC_NUM;
memset((void*)(ipc_ctrl.ipc_int_table),0x0,array_size);
ipc_ctrl.ipc_base = HI_IPCM_REGBASE_ADDR_VIRT;/*lint !e569 */
writel(0x0,(volatile void *)(ipc_ctrl.ipc_base + BSP_IPC_CPU_INT_MASK(ipc_ctrl.core_num)));
writel(0x0,(volatile void *)(ipc_ctrl.ipc_base + BSP_IPC_SEM_INT_MASK(ipc_ctrl.core_num)));
spin_lock_init(&ipc_ctrl.lock);
ret = request_irq(IPC_INT, ipc_int_handler, IRQF_NO_SUSPEND, "ipc_irq",(void*) NULL);
if (ret )
{
bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_IPC,"ipc int handler error,init failed\n");
return ERROR;
}
ret = request_irq(IPC_SEM, ipc_sem_int_handler, IRQF_NO_SUSPEND, "ipc_sem",(void*) NULL);
if (ret )
{
bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_IPC,"ipc sem handler error,init failed\n");
return ERROR;
}
bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_IPC,"ipc probe success\n");
return OK; /*lint !e438*/
}
int __init rdr_lpm3_init(void)
{
struct rdr_module_ops_pub s_module_ops;
struct rdr_exception_info_s einfo;
s32 ret = -1;
static u32 msg[4] = {0};
pr_err("enter %s\n", __func__);
/*counter_base = (char*)ioremap((phys_addr_t)SOC_ACPU_SYS_CNT_BASE_ADDR,0x1000);*/
sctrl_base = (char *)ioremap((phys_addr_t)SOC_ACPU_SCTRL_BASE_ADDR, 0x1000);
/*pr_err("counter_base: %p, sctrl_base: %p\n", counter_base, sctrl_base);*/
pr_err("sctrl_base: %p\n", sctrl_base);
ret = request_irq(M3_WDT_TIMEOUT_IRQ_NUM, m3_wdt_irq_handler, 0, "m3 wdt handler", NULL);
if (ret != 0) {
pr_err("request_irq m3_wdt_irq_handler failed! return 0x%x\n", ret);
/*return ret;*/
}
rdr_ipc_block.next = NULL;
rdr_ipc_block.notifier_call = rdr_lpm3_msg_handler;
ret = RPROC_MONITOR_REGISTER(HISI_RPROC_RDR_MBX1, &rdr_ipc_block);
if (ret != 0) {
pr_info("%s:RPROC_MONITOR_REGISTER failed", __func__);
return ret;
}
sema_init(&rdr_lpm3_sem, 0);
if (!kthread_run(rdr_lpm3_thread_body, NULL, "rdr_lpm3_thread")) {
pr_err("%s: create thread rdr_main_thread faild.\n", __func__);
return -1;
}
#if 0
ret = request_irq(AP_WDT_TIMEOUT_IRQ_NUM, ap_wdt_irq_handler, 0, "ap wdt handler", NULL);
if (ret != 0) {
pr_err("request_irq ap_wdt_irq_handler failed! return 0x%x\n", ret);
return ret;
}
#endif
s_module_ops.ops_dump = fn_dump;
s_module_ops.ops_reset = fn_reset;
ret = rdr_register_module_ops(current_core_id, &s_module_ops, ¤t_info);
if (ret != 0) {
pr_err("rdr_register_module_ops failed! return 0x%x\n", ret);
return ret;
}
memset(&einfo, 0, sizeof(struct rdr_exception_info_s));
einfo.e_modid = M3_WDT_TIMEOUT;
einfo.e_modid_end = M3_WDT_TIMEOUT;
einfo.e_process_priority = RDR_ERR;
einfo.e_reboot_priority = RDR_REBOOT_WAIT;
einfo.e_notify_core_mask = RDR_AP | RDR_LPM3;
einfo.e_reset_core_mask = RDR_LPM3;
einfo.e_reentrant = RDR_REENTRANT_DISALLOW;
einfo.e_exce_type = LPM3_S_EXCEPTION;
einfo.e_from_core = RDR_LPM3;
memcpy(einfo.e_from_module, "RDR M3 WDT", sizeof("RDR M3 WDT"));
memcpy(einfo.e_desc, "RDR M3 WDT",
sizeof("RDR M3 WDT"));
ret = rdr_register_exception(&einfo);
rdr_lpm3_buf_addr = address_map(current_info.log_addr);
rdr_lpm3_buf_len = current_info.log_len;
g_lpmcu_rdr_ddr_addr = (char *)hisi_bbox_map((phys_addr_t)current_info.log_addr, current_info.log_len);
if (g_lpmcu_rdr_ddr_addr)
memset(g_lpmcu_rdr_ddr_addr, 0 , rdr_lpm3_buf_len);
msg[0] = PSCI_MSG_TYPE_M3_RDRBUF;
msg[1] = rdr_lpm3_buf_addr;
msg[2] = rdr_lpm3_buf_addr >> 32;
msg[3] = rdr_lpm3_buf_len;
ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3_MBX17, (mbox_msg_t *)msg, 4);
if (ret != 0) {
pr_err("RPROC_ASYNC_SEND failed! return 0x%x, &msg:(%p)\n", ret, msg);
/*return ret;*/
}
pr_err("%s: (ap)->(lpm3) ipc send (0x%x 0x%x 0x%x 0x%x)!\n", __func__, msg[0], msg[1], msg[2], msg[3]);
(void)rdr_lpm3_reset_off(LPMCU_RESET_OFF_MODID_PANIC, check_himntn(HIMNTN_LPM3_PANIC_INTO_LOOP));
return ret;
}
