int rdr_lpm3_reset_off(int mod, int sw) { s32 ret = -1; unsigned int msg[2] = {0}; u32 tmp = 0; if (LPMCU_RESET_OFF_MODID_PANIC == mod) { msg[0] = PSCI_MSG_TYPE_M3_PANIC_OFF; msg[1] = sw; ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3_MBX17, (mbox_msg_t *)msg, 2); 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)!\n", __func__, msg[0], msg[1]); } else if (LPMCU_RESET_OFF_MODID_WDT == mod) { if (sctrl_base) { tmp = readl(SOC_SCTRL_SCBAKDATA10_ADDR(sctrl_base)); if (sw) { tmp &= ~((unsigned int)0x1 << 2); } else { tmp |= ((unsigned int)0x1 << 2); } writel(tmp, (void *)(SOC_SCTRL_SCBAKDATA10_ADDR(sctrl_base))); } } return 0; }
s32 bsp_ipc_int_send(IPC_INT_CORE_E enDstCore, IPC_INT_LEV_E ulLvl) { unsigned long flags = 0,ret = 0; /*如果是modem处于复位状态,则调用AP侧IPC*/ /*ap receive mabx 0,send mbx 13*/ rproc_msg_t msg[2] ; /*发送标志,用于LPM3上接收时解析*/ msg[0]=(0<<24|9<<16|3<<8|14); if(!bsp_reset_ccpu_status_get()) { if(enDstCore!=IPC_CORE_MCORE) { bsp_trace(BSP_LOG_LEVEL_ERROR,BSP_MODU_IPC," only can send to mcore\n"); return ERROR; } msg[1]=(rproc_msg_t)(1<<(u32)ulLvl); ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3 , msg ,2,ASYNC_MSG, NULL, NULL); } else { IPC_CHECK_PARA(ulLvl,IPC_INT_BUTTOM); IPC_CHECK_PARA(enDstCore,IPC_CORE_BUTTOM); /*写原始中断寄存器,产生中断*/ spin_lock_irqsave(&ipc_ctrl.lock,flags); writel((u32)1 << ulLvl,(volatile void *)(ipc_ctrl.ipc_base + BSP_IPC_CPU_RAW_INT(enDstCore))); spin_unlock_irqrestore(&ipc_ctrl.lock,flags); ipc_debug.u32RecvIntCore = enDstCore; ipc_debug.u32IntSendTimes[enDstCore][ulLvl]++; } return OK; }
void boot_iom3(void) { int ret = 0; ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3, (mbox_msg_t *)&g_boot_iom3, 1, ASYNC_MSG, inputhub_power_on_complete, NULL); if (ret) { hwlog_err("RPROC_ASYNC_SEND error in %s\n", __func__); } }
int his_modem_ipc_send(void) { int ret = 0; ret = bsp_ipc_int_send(IPC_CORE_MCORE, IPC_MCU_INT_SRC_CCPU_START); #if 0 rproc_msg_t msg = 5; ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3, &msg, 4, ASYNC_MSG, NULL, NULL); #endif return ret; }
int rdr_lpm3_stat_dump(void) { s32 ret; unsigned int msg = PSCI_MSG_TYPE_M3_STAT_DUMP; ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3_MBX17, (mbox_msg_t *)&msg, 1); if (ret != 0) { pr_err("RPROC_ASYNC_SEND failed! return 0x%x, msg:(0x%x)\n", ret, msg); return ret; } msleep(1); return 0; }
int rdr_lpm3_panic_off(int sw) { s32 ret; unsigned int msg[2] = {0}; msg[0] = PSCI_MSG_TYPE_M3_PANIC_OFF; msg[1] = sw; ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3_MBX17, (mbox_msg_t *)msg, 2); 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)!\n", __func__, msg[0], msg[1]); return 0; }
static void fn_dump(u32 modid, u32 etype, u64 coreid, char *pathname, pfn_cb_dump_done pfn_cb) { s32 ret = -1; u32 msg[2] = {PSCI_MSG_TYPE_M3_CTXSAVE, 0}; /*pr_err("[%s] [0x%x 0x%x] start\n", __func__, readl(SOC_SYSCOUNTER_CNTCV_H32_ADDR(counter_base)), readl(SOC_SYSCOUNTER_CNTCV_L32_ADDR(counter_base)));*/ pr_err("modid:0x%x,etype:0x%x,coreid:0x%llx,%s,pfn_cb:%p\n", modid, etype, coreid, pathname, pfn_cb); msg[1] = modid; pfn_cb_dumpdone = pfn_cb; g_modid = modid; strncpy(g_lpmcu_ddr_memory_path, pathname, LOG_PATH_LEN-1); ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3_MBX17, (mbox_msg_t *)&msg, 2); if (ret != 0) { pr_err("%s:RPROC_ASYNC_SEND failed! return (0x%x)\n", __func__, ret); } pr_err("%s end\n", __func__); return; }
static int hisi_sim_sem_msg_to_lpm3(struct hisi_sim_hotplug_info *info, int sim_num, int sim_state) { int ret = 0; u32 tx_buffer[2] = {0}; wake_lock(&(info->sim_hotplug_wklock)); mutex_lock(&(info->sim_hotplug_lock)); if (SIM_IN_POSITION == sim_state) { tx_buffer[0] = info->sim_info.sim_msg_input_value; tx_buffer[1] = info->sim_info.sim_msg_input_flag; } else if (SIM_LEAVE_POSITION == sim_state) { tx_buffer[0] = info->sim_info.sim_msg_output_value; tx_buffer[1] = info->sim_info.sim_msg_output_flag; } if (SIM0_ID == sim_num) { pr_info("%s, %d, tx_buffer[0]=0x%x, tx_buffer[1]=0x%x\n", __func__, __LINE__, tx_buffer[0], tx_buffer[1]); } else if (SIM1_ID == sim_num) { pr_info("%s, %d, tx_buffer[0]=0x%x, tx_buffer[1]=0x%x\n", __func__, __LINE__, tx_buffer[0], tx_buffer[1]); } /*sim hotplug state notify lpm3*/ ret = RPROC_ASYNC_SEND(HISI_RPROC_LPM3, tx_buffer, 2, ASYNC_MSG, NULL, NULL); if (ret == 0) { pr_info("%s, %d, SIM[%d] state[%d] hotplug notify lpm3 success.\n", __func__, __LINE__, sim_num, info->sim_pluged); } else { pr_err("%s, %d, failed to notify lpm3 sim hotplug state .\n\n", __func__, __LINE__); } mutex_unlock(&(info->sim_hotplug_lock)); wake_unlock(&(info->sim_hotplug_wklock)); return ret; }
int inputhub_mcu_send(const char *buf, unsigned int length) { mbox_msg_len_t len=0; int i = 0; int ret = -1; len = (length + sizeof(mbox_msg_t) - 1) / (sizeof(mbox_msg_t)); pr_debug("inputhub_mcu_send------------->length = %d, len = %d\n", (int)length, (int)len); for (i = 0; i < len; i++) pr_debug("buf[%d] = 0x%x\n", i, buf[i]); INIT_COMPLETION(send_complete); ret = RPROC_ASYNC_SEND(HISI_RPROC_IOM3, (mbox_msg_t *)buf, len, ASYNC_MSG, inputhub_mcu_send_complete, NULL); if(ret) { hwlog_err("RPROC_ASYNC_SEND return %d.\n", ret); return -1; } wait_for_completion(&send_complete); return ret; }
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; }
int test_rproc_msg_send(unsigned int sync_id, unsigned char rp_id, unsigned int msg_len, unsigned int msg_num, struct test_rproc_cb *rproc_cb) { int ret = 0; rproc_msg_t tx_buffer[8] = {0}; rproc_msg_t ack_buffer[8] = {0}; struct semaphore *complete_sema; unsigned int start_slice = 0; unsigned int end_slice = 0; unsigned int sync_task_cnt = 0; if (sync_id > 0x3) { printk(KERN_ERR "wrong sync id!\n"); return -1; } if (msg_len > 8) { printk(KERN_ERR "illegal message length!\n"); return -1; } if(rproc_cb) { down(&task_mutex_sema); rproc_cb->sync_task_cnt--; sync_task_cnt = rproc_cb->sync_task_cnt; up(&task_mutex_sema); if ((0 == sync_task_cnt) && (TEST_RPROC_NULL != rproc_cb->sync_sema)) { rproc_cb->start_slice = test_rproc_get_slice(); up(rproc_cb->sync_sema); } /*进程同步*/ if (TEST_RPROC_NULL != rproc_cb->sync_sema) { down(rproc_cb->sync_sema); up(rproc_cb->sync_sema); } } tx_buffer[0] = (OBJ_TEST << 16) | (CMD_TEST << 8)/*0x00120500*/; memcpy((void*)&tx_buffer[1], (void*)&data_buf[0], sizeof(tx_buffer) - sizeof(tx_buffer[0])); switch(sync_id) { case 0:/*同步发送同步消息*/ while(msg_num--){ ret = RPROC_SYNC_SEND(rp_id,tx_buffer, msg_len,SYNC_MSG,ack_buffer,msg_len); if (ret || (((OBJ_TEST << 16) | (CMD_TEST << 8)) != ack_buffer[0]) || (0x12345678 != ack_buffer[1])) { printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d, ack[0x%x][0x%x]!\r\n", ret, rp_id, sync_id, ack_buffer[0], ack_buffer[1]); return -1; } if(rproc_cb) rproc_cb->msg_count++; } break; case 1:/*同步发送异步消息*/ while(msg_num--){ ret = RPROC_SYNC_SEND(rp_id ,tx_buffer, msg_len,ASYNC_MSG,NULL,0); if (ret) { printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d!\r\n", ret, rp_id, sync_id); return -1; } if(rproc_cb) rproc_cb->msg_count++; } break; case 2:/*异步发送同步消息*/ while (msg_num--) { complete_sema = (struct semaphore*)kmalloc(sizeof(struct semaphore), GFP_KERNEL); sema_init(complete_sema, 0); ret = RPROC_ASYNC_SEND(rp_id,tx_buffer,msg_len,SYNC_MSG,rporc_async_callback,complete_sema); if (ret) { printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d!\r\n", ret, rp_id, sync_id); kfree(complete_sema); return -1; } start_slice = test_rproc_get_slice(); if (0 != down_timeout(complete_sema, msecs_to_jiffies(1000))) { printk(KERN_ERR "msg_send timeout rp_id:%d rproc async send err!\r\n", rp_id); /*如果超时,不能释放内存*/ /*kfree(complete_sema);*/ return -1; } end_slice = test_rproc_get_slice(); printk(KERN_INFO "async send sync msg spend %d slice!\r\n", test_rproc_slice_diff(start_slice, end_slice)); kfree(complete_sema); if(rproc_cb) rproc_cb->msg_count++; } break; case 3:/*异步发送异步消息*/ while (msg_num--) { ret = RPROC_ASYNC_SEND(rp_id,tx_buffer,msg_len,ASYNC_MSG,rporc_async_callback,NULL); if (ret) { printk(KERN_ERR "rproc send error, ret %d, rp %d, sync %d!\r\n", ret, rp_id, sync_id); return ret; } if(rproc_cb) rproc_cb->msg_count++; } break; default: printk(KERN_ERR "wrong sync ID!\n"); return -1; } printk(KERN_INFO "rproc send ok, rp %d, sync %d!\n", rp_id, sync_id); return ret; }