/** * Dump interrupt statistics. * * @s: pointer to output file */ static void smp2p_int_stats(struct seq_file *s) { struct smp2p_interrupt_config *int_cfg; int pid; int_cfg = smp2p_get_interrupt_config(); if (!int_cfg) return; seq_puts(s, "| Processor | Incoming Id | Incoming # |"); seq_puts(s, " Outgoing # | Base Ptr | Mask |\n"); for (pid = 0; pid < SMP2P_NUM_PROCS; ++pid) { if (!int_cfg[pid].is_configured && pid != SMP2P_REMOTE_MOCK_PROC) continue; seq_printf(s, "| %5s (%d) | %11u | %10u | %10u | %p | %08x |\n", int_cfg[pid].name, pid, int_cfg[pid].in_int_id, int_cfg[pid].in_interrupt_count, int_cfg[pid].out_interrupt_count, int_cfg[pid].out_int_ptr, int_cfg[pid].out_int_mask); } }
/** * smp2p_remote_mock_init - Initialize the remote mock and loopback objects. * * @returns: 0 for success */ static int __init smp2p_remote_mock_init(void) { int i; struct smp2p_interrupt_config *int_cfg; smp2p_init_header(&remote_mock.remote_item.header, SMP2P_REMOTE_MOCK_PROC, SMP2P_APPS_PROC, 0, 0); remote_mock.rx_interrupt_count = 0; remote_mock.rx_interrupt = smp2p_remote_mock_rx_interrupt; remote_mock.tx_interrupt = smp2p_remote_mock_tx_interrupt; remote_mock.item_exists = false; init_completion(&remote_mock.cb_completion); remote_mock.initialized = true; for (i = 0; i < SMP2P_NUM_PROCS; i++) { INIT_WORK(&(remote_loopback[i].rmt_lpb_work), smp2p_rmt_lpb_worker); if (i == SMP2P_REMOTE_MOCK_PROC) /* do not register loopback for remote mock proc */ continue; int_cfg = smp2p_get_interrupt_config(); if (!int_cfg) { SMP2P_ERR("Remote processor config unavailable\n"); return 0; } if (!int_cfg[i].is_configured) continue; msm_smp2p_init_rmt_lpb(&remote_loopback[i], i, SMP2P_RLPB_ENTRY_NAME); } return 0; }
/** * smp2p_ut_remote_out_max_entries - Verify open for all configured processors. * * @s: pointer to output file * * This test verifies creating max number of entries for * all configured remote processor. */ static void smp2p_ut_remote_out_max_entries(struct seq_file *s) { struct smp2p_interrupt_config *int_cfg; int pid; int_cfg = smp2p_get_interrupt_config(); if (!int_cfg) { seq_printf(s, "Remote processor config unavailable\n"); return; } for (pid = 0; pid < SMP2P_NUM_PROCS; ++pid) { if (!int_cfg[pid].is_configured) continue; smp2p_ut_remote_out_max_entries_core(s, pid); } }
/** * Dump individual input/output item pair. * * @s: pointer to output file */ static void smp2p_item(struct seq_file *s, int remote_pid) { struct smp2p_smem *out_ptr; struct smp2p_smem *in_ptr; struct smp2p_interrupt_config *int_cfg; char tmp_buff[64]; int state; int entry; struct smp2p_entry_v1 *out_entries = NULL; struct smp2p_entry_v1 *in_entries = NULL; int out_valid = 0; int in_valid = 0; char entry_name[SMP2P_MAX_ENTRY_NAME]; int_cfg = smp2p_get_interrupt_config(); if (!int_cfg) return; if (!int_cfg[remote_pid].is_configured && remote_pid != SMP2P_REMOTE_MOCK_PROC) return; out_ptr = smp2p_get_out_item(remote_pid, &state); in_ptr = smp2p_get_in_item(remote_pid); if (!out_ptr && !in_ptr) return; /* print item headers */ seq_printf(s, "%s%s\n", " ====================================== ", "======================================"); scnprintf(tmp_buff, sizeof(tmp_buff), "Apps(%d)->%s(%d)", SMP2P_APPS_PROC, int_cfg[remote_pid].name, remote_pid); seq_printf(s, "| %-37s", tmp_buff); scnprintf(tmp_buff, sizeof(tmp_buff), "%s(%d)->Apps(%d)", int_cfg[remote_pid].name, remote_pid, SMP2P_APPS_PROC); seq_printf(s, "| %-37s|\n", tmp_buff); seq_printf(s, "%s%s\n", " ====================================== ", "======================================"); smp2p_item_header1(tmp_buff, sizeof(tmp_buff), out_ptr, state); seq_printf(s, "| %-37s", tmp_buff); smp2p_item_header1(tmp_buff, sizeof(tmp_buff), in_ptr, -1); seq_printf(s, "| %-37s|\n", tmp_buff); smp2p_item_header2(tmp_buff, sizeof(tmp_buff), out_ptr); seq_printf(s, "| %-37s", tmp_buff); smp2p_item_header2(tmp_buff, sizeof(tmp_buff), in_ptr); seq_printf(s, "| %-37s|\n", tmp_buff); smp2p_item_header3(tmp_buff, sizeof(tmp_buff), out_ptr); seq_printf(s, "| %-37s", tmp_buff); smp2p_item_header3(tmp_buff, sizeof(tmp_buff), in_ptr); seq_printf(s, "| %-37s|\n", tmp_buff); seq_printf(s, " %s%s\n", "-------------------------------------- ", "--------------------------------------"); seq_printf(s, "| %-37s", "Entry Name Value"); seq_printf(s, "| %-37s|\n", "Entry Name Value"); seq_printf(s, " %s%s\n", "-------------------------------------- ", "--------------------------------------"); /* print entries */ if (out_ptr) { out_entries = (struct smp2p_entry_v1 *)((void *)out_ptr + sizeof(struct smp2p_smem)); out_valid = SMP2P_GET_ENT_VALID(out_ptr->valid_total_ent); } if (in_ptr) { in_entries = (struct smp2p_entry_v1 *)((void *)in_ptr + sizeof(struct smp2p_smem)); in_valid = SMP2P_GET_ENT_VALID(in_ptr->valid_total_ent); } for (entry = 0; out_entries || in_entries; ++entry) { if (out_entries && entry < out_valid) { memcpy_fromio(entry_name, out_entries->name, SMP2P_MAX_ENTRY_NAME); scnprintf(tmp_buff, sizeof(tmp_buff), "%-16s 0x%08x", entry_name, out_entries->entry); ++out_entries; } else { out_entries = NULL; scnprintf(tmp_buff, sizeof(tmp_buff), "None"); } seq_printf(s, "| %-37s", tmp_buff); if (in_entries && entry < in_valid) { memcpy_fromio(entry_name, in_entries->name, SMP2P_MAX_ENTRY_NAME); scnprintf(tmp_buff, sizeof(tmp_buff), "%-16s 0x%08x", entry_name, in_entries->entry); ++in_entries; } else { in_entries = NULL; scnprintf(tmp_buff, sizeof(tmp_buff), "None"); } seq_printf(s, "| %-37s|\n", tmp_buff); } seq_printf(s, " %s%s\n\n", "-------------------------------------- ", "--------------------------------------"); }