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;
}
