/* * Copyright (c) 2018 Samsung Electronics Co., Ltd. * http://www.samsung.com * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CONFIG_EXYNOS_ADV_TRACER #include #endif #include #include #include #include #include #ifdef CONFIG_EXYNOS_ITMON #include #endif #ifdef CONFIG_UH_RKP struct exynos_bcm_dbg_data *bcm_dbg_data; EXPORT_SYMBOL(bcm_dbg_data); #else static struct exynos_bcm_dbg_data *bcm_dbg_data; #endif #ifdef CONFIG_EXYNOS_BCM_DBG_GNR static void *bcm_addr; static struct bin_system_func *bin_func; static struct os_system_func os_func; typedef struct bin_system_func*(*start_up_func_t)(void **func); #endif #if defined(CONFIG_EXYNOS_ADV_TRACER) || defined(CONFIG_EXYNOS_BCM_DBG_GNR) static enum exynos_bcm_err_code exynos_bcm_dbg_ipc_err_handle(unsigned int cmd) { enum exynos_bcm_err_code err_code; err_code = BCM_CMD_GET(cmd, BCM_ERR_MASK, BCM_ERR_SHIFT); if (err_code) BCM_ERR("%s: BCM IPC error return(%u)\n", __func__, err_code); return err_code; } #endif static int exynos_bcm_ip_validate(unsigned int ip_range, unsigned int ip_index, unsigned int bcm_ip_nr) { if (ip_range >= BCM_RANGE_MAX) { BCM_ERR("%s: Invalid ip range(%u)\n", __func__, ip_range); BCM_ERR("%s: BCM_EACH(%d), BCM_ALL(%d)\n", __func__, BCM_EACH, BCM_ALL); return -EINVAL; } if (ip_index >= bcm_ip_nr) { BCM_ERR("%s: Invalid ip index(%u), ip_max_nr(%u)\n", __func__, ip_index, bcm_ip_nr - 1); return -EINVAL; } return 0; } static int exynos_bcm_is_running(unsigned int run_state) { if (run_state == BCM_RUN) { BCM_ERR("%s: do not set when bcm is running(%u)\n", __func__, run_state); return -EBUSY; } return 0; } static int __exynos_bcm_dbg_ipc_send_data(enum exynos_bcm_dbg_ipc_type ipc_type, struct exynos_bcm_dbg_data *data, unsigned int *cmd) { int i, ret = 0; #if defined(CONFIG_EXYNOS_ADV_TRACER) struct adv_tracer_ipc_cmd config; #elif defined(CONFIG_EXYNOS_BCM_DBG_GNR) struct cmd_data config; #endif enum exynos_bcm_err_code ipc_err; unsigned int *bcm_cmd; if ((ipc_type < IPC_BCM_DBG_EVENT) || (ipc_type >= IPC_BCM_DBG_MAX)) { BCM_ERR("%s: Invalid IPC Type: %d\n", __func__, ipc_type); ret = -EINVAL; return ret; } bcm_cmd = cmd; #if defined(CONFIG_EXYNOS_ADV_TRACER) config.cmd_raw.cmd = BCM_CMD_SET(ipc_type, BCM_CMD_ID_MASK, BCM_CMD_ID_SHIFT); memcpy(&config.buffer[1], bcm_cmd, sizeof(unsigned int) * CMD_DATA_MAX); ret = adv_tracer_ipc_send_data_polling(data->ipc_ch_num, &config); #elif defined(CONFIG_EXYNOS_BCM_DBG_GNR) config.raw_cmd = BCM_CMD_SET(ipc_type, BCM_CMD_ID_MASK, BCM_CMD_ID_SHIFT); memcpy(config.cmd, bcm_cmd, sizeof(unsigned int) * CMD_DATA_MAX); ret = bin_func->send_data(&config); #endif if (ret) { BCM_ERR("%s: Failed to send IPC(%d:%u) data to origin\n", __func__, ipc_type, data->ipc_ch_num); return ret; } #if defined(CONFIG_EXYNOS_ADV_TRACER) for (i = 0; i < data->ipc_size; i++) BCM_DBG("%s: received data[%d]: 0x%08x\n", __func__, i, config.buffer[i]); memcpy(bcm_cmd, &config.buffer[1], sizeof(unsigned int) * CMD_DATA_MAX); ipc_err = exynos_bcm_dbg_ipc_err_handle(config.cmd_raw.cmd); #elif defined(CONFIG_EXYNOS_BCM_DBG_GNR) BCM_DBG("%s: received data raw: 0x%08x\n", __func__, config.raw_cmd); for (i = 0; i < CMD_DATA_MAX; i++) BCM_DBG("%s: received data[%d]: 0x%08x\n", __func__, i, config.cmd[i]); memcpy(bcm_cmd, config.cmd, sizeof(unsigned int) * CMD_DATA_MAX); ipc_err = exynos_bcm_dbg_ipc_err_handle(config.raw_cmd); #endif if (ipc_err) { ret = -EBADMSG; return ret; } return 0; } int exynos_bcm_dbg_ipc_send_data(enum exynos_bcm_dbg_ipc_type ipc_type, struct exynos_bcm_dbg_data *data, unsigned int *cmd) { int ret; unsigned long flags; if (!data) { BCM_ERR("%s: data is not ready!\n", __func__); return -ENODEV; } spin_lock_irqsave(&data->lock, flags); ret = __exynos_bcm_dbg_ipc_send_data(ipc_type, data, cmd); spin_unlock_irqrestore(&data->lock, flags); return ret; } EXPORT_SYMBOL(exynos_bcm_dbg_ipc_send_data); #ifdef CONFIG_EXYNOS_ADV_TRACER static int adv_tracer_bcm_dbg_handler(struct adv_tracer_ipc_cmd *cmd, unsigned int len) { return 0; } static int exynos_bcm_dbg_ipc_channel_request(struct exynos_bcm_dbg_data *data) { int ret = 0; ret = adv_tracer_ipc_request_channel(data->ipc_node, (ipc_callback)adv_tracer_bcm_dbg_handler, &data->ipc_ch_num, &data->ipc_size); if (ret) { BCM_ERR("%s: adv tracer request channel is failed\n", __func__); return ret; } BCM_INFO("ipc channel info: ch_num(%u), size(%u)\n", data->ipc_ch_num, data->ipc_size); return ret; } static void exynos_bcm_dbg_ipc_channel_release(struct exynos_bcm_dbg_data *data) { adv_tracer_ipc_release_channel(data->ipc_ch_num); } #else static inline int exynos_bcm_dbg_ipc_channel_request(struct exynos_bcm_dbg_data *data) { return 0; } static inline void exynos_bcm_dbg_ipc_channel_release(struct exynos_bcm_dbg_data *data) { } #endif static int exynos_bcm_dbg_early_pd_sync(unsigned int cal_pdid, bool on) { unsigned int cmd[4] = {0, }; unsigned long flags; struct exynos_bcm_pd_info *bcm_pd_info = NULL; int i, ret = 0; spin_lock_irqsave(&bcm_dbg_data->lock, flags); for (i = 0; i < bcm_dbg_data->pd_size; i++) { if (bcm_dbg_data->pd_info[i]->cal_pdid == cal_pdid) { bcm_pd_info = bcm_dbg_data->pd_info[i]; break; } } if (!bcm_pd_info) { ret = -EINVAL; goto out; } if (on ^ bcm_pd_info->on) { bcm_pd_info->on = on; /* Generate IPC command for PD sync */ cmd[0] |= BCM_CMD_SET(bcm_pd_info->pd_index, BCM_PD_INFO_MASK, BCM_PD_INFO_SHIFT); cmd[0] |= BCM_CMD_SET((unsigned int)on, BCM_ONE_BIT_MASK, BCM_PD_ON_SHIFT); cmd[1] = 0; cmd[2] = 0; cmd[3] = 0; /* send command for PD sync */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_PD, bcm_dbg_data, cmd); if (ret) { BCM_ERR("%s: Failed send data for pd sync\n", __func__); goto out; } } out: spin_unlock_irqrestore(&bcm_dbg_data->lock, flags); return ret; } int exynos_bcm_dbg_pd_sync(unsigned int cal_pdid, bool on) { unsigned int cmd[4] = {0, }; unsigned long flags; struct exynos_bcm_pd_info *bcm_pd_info = NULL; int i, ret = 0; if (!bcm_dbg_data || !bcm_dbg_data->pd_sync_init) { BCM_DBG("%s: do not pd_sync_init(%s)\n", __func__, bcm_dbg_data->pd_sync_init ? "true" : "false"); return 0; } spin_lock_irqsave(&bcm_dbg_data->lock, flags); for (i = 0; i < bcm_dbg_data->pd_size; i++) { if (bcm_dbg_data->pd_info[i]->cal_pdid == cal_pdid) { bcm_pd_info = bcm_dbg_data->pd_info[i]; break; } } if (!bcm_pd_info) { ret = -EINVAL; goto out; } if (on ^ bcm_pd_info->on) { bcm_pd_info->on = on; /* Generate IPC command for PD sync */ cmd[0] |= BCM_CMD_SET(bcm_pd_info->pd_index, BCM_PD_INFO_MASK, BCM_PD_INFO_SHIFT); cmd[0] |= BCM_CMD_SET((unsigned int)on, BCM_ONE_BIT_MASK, BCM_PD_ON_SHIFT); cmd[1] = 0; cmd[2] = 0; cmd[3] = 0; /* send command for PD sync */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_PD, bcm_dbg_data, cmd); if (ret) { BCM_ERR("%s: Failed send data for pd sync\n", __func__); goto out; } } out: spin_unlock_irqrestore(&bcm_dbg_data->lock, flags); return ret; } EXPORT_SYMBOL(exynos_bcm_dbg_pd_sync); static int exynos_bcm_dbg_pd_sync_init(struct exynos_bcm_dbg_data *data) { struct exynos_pm_domain *exynos_pd; unsigned int pd_index, pd_size; int ret = 0; if (data->pd_sync_init) { BCM_ERR("%s: already pd_sync_init(%s)\n", __func__, data->pd_sync_init ? "true" : "false"); return -EINVAL; } pd_size = data->pd_size; for (pd_index = 0; pd_index < pd_size; pd_index++) { exynos_pd = NULL; data->pd_info[pd_index]->on = false; exynos_pd = exynos_pd_lookup_name(data->pd_info[pd_index]->pd_name); if (exynos_pd) { mutex_lock(&exynos_pd->access_lock); exynos_pd->bcm = data->pd_info[pd_index]; data->pd_info[pd_index]->cal_pdid = exynos_pd->cal_pdid; if (cal_pd_status(exynos_pd->cal_pdid)) { ret = exynos_bcm_dbg_pd_sync(data->pd_info[pd_index]->cal_pdid, true); if (ret) { mutex_unlock(&exynos_pd->access_lock); return ret; } } mutex_unlock(&exynos_pd->access_lock); } else { ret = exynos_bcm_dbg_early_pd_sync(data->pd_info[pd_index]->cal_pdid, true); if (ret) return ret; } } data->pd_sync_init = true; return ret; } static int exynos_bcm_dbg_pd_sync_exit(struct exynos_bcm_dbg_data *data) { struct exynos_pm_domain *exynos_pd; unsigned int pd_index, pd_size; int ret = 0; if (!data->pd_sync_init) { BCM_ERR("%s: already pd_sync_exit(%s)\n", __func__, data->pd_sync_init ? "true" : "false"); return -EINVAL; } pd_size = data->pd_size; for (pd_index = 0; pd_index < pd_size; pd_index++) { exynos_pd = exynos_pd_lookup_name(data->pd_info[pd_index]->pd_name); if (exynos_pd) { mutex_lock(&exynos_pd->access_lock); exynos_pd->bcm = NULL; ret = exynos_bcm_dbg_pd_sync(data->pd_info[pd_index]->cal_pdid, false); if (ret) { mutex_unlock(&exynos_pd->access_lock); return ret; } mutex_unlock(&exynos_pd->access_lock); } else { ret = exynos_bcm_dbg_pd_sync(data->pd_info[pd_index]->cal_pdid, false); if (ret) return ret; } } data->pd_sync_init = false; return ret; } static void exynos_bcm_dbg_set_base_info( struct exynos_bcm_ipc_base_info *ipc_base_info, enum exynos_bcm_event_id event_id, enum exynos_bcm_event_dir direction, enum exynos_bcm_ip_range ip_range) { ipc_base_info->event_id = event_id; ipc_base_info->ip_range = ip_range; ipc_base_info->direction = direction; } static void exynos_bcm_dbg_set_base_cmd(unsigned int *cmd, struct exynos_bcm_ipc_base_info *ipc_base_info) { cmd[0] = 0; cmd[0] |= BCM_CMD_SET(ipc_base_info->event_id, BCM_EVT_ID_MASK, BCM_EVT_ID_SHIFT); cmd[0] |= BCM_CMD_SET(ipc_base_info->ip_range, BCM_ONE_BIT_MASK, BCM_IP_RANGE_SHIFT); cmd[0] |= BCM_CMD_SET(ipc_base_info->direction, BCM_ONE_BIT_MASK, BCM_EVT_DIR_SHIFT); } static int exynos_bcm_dbg_event_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, struct exynos_bcm_event *bcm_event, unsigned int bcm_ip_index, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; int i, ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info || !bcm_event) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_PRE_DEFINE && ipc_base_info->event_id != BCM_EVT_EVENT) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->ip_range == BCM_EACH) cmd[0] |= BCM_CMD_SET(bcm_ip_index, BCM_IP_MASK, BCM_IP_SHIFT); if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; cmd[0] |= BCM_CMD_SET(bcm_event->index, BCM_EVT_PRE_DEFINE_MASK, BCM_EVT_PRE_DEFINE_SHIFT); for (i = 0; i < BCM_EVT_EVENT_MAX / 2; i++) { cmd[1] |= BCM_CMD_SET(bcm_event->event[i], BCM_EVT_EVENT_MASK, BCM_EVT_EVENT_SHIFT(i)); if (data->bcm_cnt_nr > 4) { cmd[2] |= BCM_CMD_SET(bcm_event->event[i + 4], BCM_EVT_EVENT_MASK, BCM_EVT_EVENT_SHIFT(i + 4)); } } } /* send command for BCM Event */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { bcm_event->index = BCM_CMD_GET(cmd[0], BCM_EVT_PRE_DEFINE_MASK, BCM_EVT_PRE_DEFINE_SHIFT); for (i = 0; i < BCM_EVT_EVENT_MAX / 2; i++) { bcm_event->event[i] = BCM_CMD_GET(cmd[1], BCM_EVT_EVENT_MASK, BCM_EVT_EVENT_SHIFT(i)); if (data->bcm_cnt_nr > 4) { bcm_event->event[i + 4] = BCM_CMD_GET(cmd[2], BCM_EVT_EVENT_MASK, BCM_EVT_EVENT_SHIFT(i + 4)); } } } out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_filter_id_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, struct exynos_bcm_filter_id *filter_id, unsigned int bcm_ip_index, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; int i, ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info || !filter_id) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_EVENT_FLT_ID) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->ip_range == BCM_EACH) cmd[0] |= BCM_CMD_SET(bcm_ip_index, BCM_IP_MASK, BCM_IP_SHIFT); if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; cmd[1] = filter_id->sm_id_mask; cmd[2] = filter_id->sm_id_value; for (i = 0; i < data->bcm_cnt_nr; i++) cmd[3] |= BCM_CMD_SET(filter_id->sm_id_active[i], BCM_ONE_BIT_MASK, BCM_EVT_FLT_ACT_SHIFT(i)); } /* send command for BCM Filter ID */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { filter_id->sm_id_mask = cmd[1]; filter_id->sm_id_value = cmd[2]; for (i = 0; i < data->bcm_cnt_nr; i++) filter_id->sm_id_active[i] = BCM_CMD_GET(cmd[3], BCM_ONE_BIT_MASK, BCM_EVT_FLT_ACT_SHIFT(i)); } out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_filter_others_ctrl( struct exynos_bcm_ipc_base_info *ipc_base_info, struct exynos_bcm_filter_others *filter_others, unsigned int bcm_ip_index, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; int i, ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info || !filter_others) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_EVENT_FLT_OTHERS) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->ip_range == BCM_EACH) cmd[0] |= BCM_CMD_SET(bcm_ip_index, BCM_IP_MASK, BCM_IP_SHIFT); if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; for (i = 0; i < BCM_EVT_FLT_OTHR_MAX; i++) { cmd[1] |= BCM_CMD_SET(filter_others->sm_other_type[i], BCM_EVT_FLT_OTHR_TYPE_MASK, BCM_EVT_FLT_OTHR_TYPE_SHIFT(i)); cmd[1] |= BCM_CMD_SET(filter_others->sm_other_mask[i], BCM_EVT_FLT_OTHR_MASK_MASK, BCM_EVT_FLT_OTHR_MASK_SHIFT(i)); cmd[1] |= BCM_CMD_SET(filter_others->sm_other_value[i], BCM_EVT_FLT_OTHR_VALUE_MASK, BCM_EVT_FLT_OTHR_VALUE_SHIFT(i)); } for (i = 0; i < data->bcm_cnt_nr; i++) cmd[2] |= BCM_CMD_SET(filter_others->sm_other_active[i], BCM_ONE_BIT_MASK, BCM_EVT_FLT_ACT_SHIFT(i)); } /* send command for BCM Filter Others */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { for (i = 0; i < BCM_EVT_FLT_OTHR_MAX; i++) { filter_others->sm_other_type[i] = BCM_CMD_GET(cmd[1], BCM_EVT_FLT_OTHR_TYPE_MASK, BCM_EVT_FLT_OTHR_TYPE_SHIFT(i)); filter_others->sm_other_mask[i] = BCM_CMD_GET(cmd[1], BCM_EVT_FLT_OTHR_MASK_MASK, BCM_EVT_FLT_OTHR_MASK_SHIFT(i)); filter_others->sm_other_value[i] = BCM_CMD_GET(cmd[1], BCM_EVT_FLT_OTHR_VALUE_MASK, BCM_EVT_FLT_OTHR_VALUE_SHIFT(i)); } for (i = 0; i < data->bcm_cnt_nr; i++) filter_others->sm_other_active[i] = BCM_CMD_GET(cmd[2], BCM_ONE_BIT_MASK, BCM_EVT_FLT_ACT_SHIFT(i)); } out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_sample_id_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, struct exynos_bcm_sample_id *sample_id, unsigned int bcm_ip_index, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; int i, ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info || !sample_id) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_EVENT_SAMPLE_ID) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->ip_range == BCM_EACH) cmd[0] |= BCM_CMD_SET(bcm_ip_index, BCM_IP_MASK, BCM_IP_SHIFT); if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; cmd[1] = sample_id->peak_mask; cmd[2] = sample_id->peak_id; for (i = 0; i < data->bcm_cnt_nr; i++) cmd[3] |= BCM_CMD_SET(sample_id->peak_enable[i], BCM_ONE_BIT_MASK, BCM_EVT_FLT_ACT_SHIFT(i)); } /* send command for BCM Sample ID */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { sample_id->peak_mask = cmd[1]; sample_id->peak_id = cmd[2]; for (i = 0; i < data->bcm_cnt_nr; i++) sample_id->peak_enable[i] = BCM_CMD_GET(cmd[3], BCM_ONE_BIT_MASK, BCM_EVT_FLT_ACT_SHIFT(i)); } out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_run_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, unsigned int *bcm_run, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; unsigned int run, low_ktime, high_ktime; int ret = 0; u64 ktime; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_RUN_CONT) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->direction == BCM_EVT_SET) { run = *bcm_run; if (!(run ^ data->bcm_run_state)) { BCM_INFO("%s: same run control command(%u) bcm_run_state(%u)\n", __func__, run, data->bcm_run_state); goto out; } cmd[0] |= BCM_CMD_SET(run, BCM_ONE_BIT_MASK, BCM_EVT_RUN_CONT_SHIFT); if (run == BCM_STOP) { ktime = sched_clock(); low_ktime = (unsigned int)(ktime & EXYNOS_BCM_U64_LOW_MASK); high_ktime = (unsigned int)((ktime & EXYNOS_BCM_U64_HIGH_MASK) >> EXYNOS_BCM_32BIT_SHIFT); cmd[1] = low_ktime; cmd[2] = high_ktime; #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (data->bcm_mode != BCM_MODE_USERCTRL) hrtimer_try_to_cancel(&data->bcm_hrtimer); #endif } } /* send command for BCM Run */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { run = BCM_CMD_GET(cmd[0], BCM_ONE_BIT_MASK, BCM_EVT_RUN_CONT_SHIFT); *bcm_run = run; } else if (ipc_base_info->direction == BCM_EVT_SET) { data->bcm_run_state = run; #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (run == BCM_RUN && data->bcm_mode != BCM_MODE_USERCTRL) hrtimer_start(&data->bcm_hrtimer, ms_to_ktime(data->period), HRTIMER_MODE_REL); #endif } spin_unlock_irqrestore(&data->lock, flags); /* dumping data from buffer */ if (run == BCM_STOP && ipc_base_info->direction == BCM_EVT_SET) exynos_bcm_dbg_buffer_dump(data, data->dump_klog); return ret; out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_period_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, unsigned int *bcm_period, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; unsigned int period; int ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_PERIOD_CONT) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; period = *bcm_period; /* valid check for period range */ if (!(period >= BCM_TIMER_PERIOD_MIN && period <= BCM_TIMER_PERIOD_MAX)) { BCM_ERR("%s: Invalid period range(%umsec),(%d ~ %dmsec)\n", __func__, period, BCM_TIMER_PERIOD_MIN, BCM_TIMER_PERIOD_MAX); ret = -EINVAL; goto out; } cmd[1] |= BCM_CMD_SET(period, BCM_EVT_PERIOD_CONT_MASK, BCM_EVT_PERIOD_CONT_SHIFT); } /* send command for BCM Period */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { period = BCM_CMD_GET(cmd[1], BCM_EVT_PERIOD_CONT_MASK, BCM_EVT_PERIOD_CONT_SHIFT); *bcm_period = period; } #ifdef CONFIG_EXYNOS_BCM_DBG_GNR data->period = period; #endif out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_mode_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, unsigned int *bcm_mode, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; unsigned int mode; int ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_MODE_CONT) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; mode = *bcm_mode; if (mode >= BCM_MODE_MAX) { BCM_ERR("%s: Invalid BCM mode(%u), BCM mode max(%d)\n", __func__, mode, BCM_MODE_MAX); ret = -EINVAL; goto out; } cmd[0] |= BCM_CMD_SET(mode, BCM_EVT_MODE_CONT_MASK, BCM_EVT_MODE_CONT_SHIFT); } /* send command for BCM Mode */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { mode = BCM_CMD_GET(cmd[0], BCM_EVT_MODE_CONT_MASK, BCM_EVT_MODE_CONT_SHIFT); *bcm_mode = mode; } #ifdef CONFIG_EXYNOS_BCM_DBG_GNR data->bcm_mode = mode; #endif out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_str_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, unsigned int *ap_suspend, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; unsigned int suspend; int ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_STR_STATE) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->direction == BCM_EVT_SET) { suspend = *ap_suspend; cmd[0] |= BCM_CMD_SET(suspend, BCM_ONE_BIT_MASK, BCM_EVT_STR_STATE_SHIFT); #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (suspend && data->bcm_mode != BCM_MODE_USERCTRL) hrtimer_try_to_cancel(&data->bcm_hrtimer); #endif } /* send command for BCM STR state */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { suspend = BCM_CMD_GET(cmd[0], BCM_ONE_BIT_MASK, BCM_EVT_STR_STATE_SHIFT); *ap_suspend = suspend; } #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (ipc_base_info->direction == BCM_EVT_SET) { if (!suspend && data->bcm_mode != BCM_MODE_USERCTRL) hrtimer_start(&data->bcm_hrtimer, ms_to_ktime(data->period), HRTIMER_MODE_REL); } #endif out: spin_unlock_irqrestore(&data->lock, flags); return ret; } static int exynos_bcm_dbg_ip_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, unsigned int *bcm_ip_enable, unsigned int bcm_ip_index, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; unsigned int ip_enable; int ret = 0; unsigned long flags; spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_IP_CONT) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->ip_range == BCM_EACH) cmd[0] |= BCM_CMD_SET(bcm_ip_index, BCM_IP_MASK, BCM_IP_SHIFT); if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; ip_enable = *bcm_ip_enable; cmd[0] |= BCM_CMD_SET(ip_enable, BCM_ONE_BIT_MASK, BCM_EVT_IP_CONT_SHIFT); } /* send command for BCM IP control */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } if (ipc_base_info->direction == BCM_EVT_GET) { ip_enable = BCM_CMD_GET(cmd[0], BCM_ONE_BIT_MASK, BCM_EVT_IP_CONT_SHIFT); *bcm_ip_enable = ip_enable; } out: spin_unlock_irqrestore(&data->lock, flags); return ret; } #ifdef CONFIG_DEBUG_SNAPSHOT static int exynos_bcm_dbg_dump_addr_ctrl(struct exynos_bcm_ipc_base_info *ipc_base_info, struct exynos_bcm_dump_addr *dump_addr, struct exynos_bcm_dbg_data *data) { unsigned int cmd[4] = {0, 0, 0, 0}; int ret = 0; unsigned long flags; #ifdef CONFIG_EXYNOS_BCM_DBG_GNR u64 v_addr; #endif spin_lock_irqsave(&data->lock, flags); if (!ipc_base_info) { BCM_ERR("%s: pointer is NULL\n", __func__); ret = -EINVAL; goto out; } exynos_bcm_dbg_set_base_cmd(cmd, ipc_base_info); if (ipc_base_info->event_id != BCM_EVT_DUMP_ADDR) { BCM_ERR("%s: Invalid Event ID(%d)\n", __func__, ipc_base_info->event_id); ret = -EINVAL; goto out; } if (ipc_base_info->direction == BCM_EVT_SET) { /* * check bcm running state * When bcm is running, value can not set */ ret = exynos_bcm_is_running(data->bcm_run_state); if (ret) goto out; #ifdef CONFIG_EXYNOS_BCM_DBG_GNR v_addr = (u64)dump_addr->v_addr; if (!v_addr || !dump_addr->buff_size) { BCM_ERR("%s: No dump address info: v_addr(%llu), buff_size(0x%08x)\n", __func__, v_addr, dump_addr->buff_size); ret = -EINVAL; goto out; } cmd[1] = (unsigned int)(v_addr & EXYNOS_BCM_U64_LOW_MASK); cmd[2] = (unsigned int)((v_addr & EXYNOS_BCM_U64_HIGH_MASK) >> EXYNOS_BCM_32BIT_SHIFT); cmd[3] = (unsigned int)dump_addr->buff_size; #else if (!dump_addr->p_addr || !dump_addr->buff_size) { BCM_ERR("%s: No dump address info: p_addr(0x%08x), buff_size(0x%08x)\n", __func__, dump_addr->p_addr, dump_addr->buff_size); ret = -EINVAL; goto out; } cmd[1] = (unsigned int)dump_addr->p_addr; cmd[2] = (unsigned int)dump_addr->buff_size; #endif } /* send command for BCM Dump address info */ ret = __exynos_bcm_dbg_ipc_send_data(IPC_BCM_DBG_EVENT, data, cmd); if (ret) { BCM_ERR("%s: Failed send data\n", __func__); goto out; } out: spin_unlock_irqrestore(&data->lock, flags); return ret; } #endif static int exynos_bcm_dbg_early_init(struct exynos_bcm_dbg_data *data) { struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_event bcm_event; struct exynos_bcm_filter_id filter_id; struct exynos_bcm_filter_others filter_others; struct exynos_bcm_sample_id sample_id; unsigned int default_event; int ev_cnt, othr_cnt, ip_cnt; int ret = 0; /* pre-defined event set */ exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_PRE_DEFINE, BCM_EVT_SET, BCM_ALL); default_event = data->default_define_event; bcm_event.index = data->define_event[default_event].index; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) bcm_event.event[ev_cnt] = data->define_event[default_event].event[ev_cnt]; ret = exynos_bcm_dbg_event_ctrl(&ipc_base_info, &bcm_event, 0, data); if (ret) { BCM_ERR("%s: failed set event\n", __func__); return ret; } /* default filter id set */ exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_ID, BCM_EVT_SET, BCM_ALL); filter_id.sm_id_mask = data->define_filter_id[default_event].sm_id_mask; filter_id.sm_id_value = data->define_filter_id[default_event].sm_id_value; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) filter_id.sm_id_active[ev_cnt] = data->define_filter_id[default_event].sm_id_active[ev_cnt]; ret = exynos_bcm_dbg_filter_id_ctrl(&ipc_base_info, &filter_id, 0, data); if (ret) { BCM_ERR("%s: failed set filter ID\n", __func__); return ret; } /* default filter others set */ exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_OTHERS, BCM_EVT_SET, BCM_ALL); for (othr_cnt = 0; othr_cnt < BCM_EVT_FLT_OTHR_MAX; othr_cnt++) { filter_others.sm_other_type[othr_cnt] = data->define_filter_others[default_event].sm_other_type[othr_cnt]; filter_others.sm_other_mask[othr_cnt] = data->define_filter_others[default_event].sm_other_mask[othr_cnt]; filter_others.sm_other_value[othr_cnt] = data->define_filter_others[default_event].sm_other_value[othr_cnt]; } for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) filter_others.sm_other_active[ev_cnt] = data->define_filter_others[default_event].sm_other_active[ev_cnt]; ret = exynos_bcm_dbg_filter_others_ctrl(&ipc_base_info, &filter_others, 0, data); if (ret) { BCM_ERR("%s: failed set filter others\n", __func__); return ret; } /* default sample id set */ exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_SAMPLE_ID, BCM_EVT_SET, BCM_ALL); sample_id.peak_mask = data->define_sample_id[default_event].peak_mask; sample_id.peak_id = data->define_sample_id[default_event].peak_id; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) sample_id.peak_enable[ev_cnt] = data->define_sample_id[default_event].peak_enable[ev_cnt]; ret = exynos_bcm_dbg_sample_id_ctrl(&ipc_base_info, &sample_id, 0, data); if (ret) { BCM_ERR("%s: failed set sample ID\n", __func__); return ret; } /* default period set */ exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_PERIOD_CONT, BCM_EVT_SET, 0); ret = exynos_bcm_dbg_period_ctrl(&ipc_base_info, &data->initial_period, data); if (ret) { BCM_ERR("%s: failed set period\n", __func__); return ret; } /* default mode set */ exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_MODE_CONT, BCM_EVT_SET, 0); ret = exynos_bcm_dbg_mode_ctrl(&ipc_base_info, &data->initial_bcm_mode, data); if (ret) { BCM_ERR("%s: failed set mode\n", __func__); return ret; } /* default run ip set */ for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_IP_CONT, BCM_EVT_SET, BCM_EACH); ret = exynos_bcm_dbg_ip_ctrl(&ipc_base_info, &data->initial_run_ip[ip_cnt], ip_cnt, data); if (ret) { BCM_ERR("%s: failed set IP control\n", __func__); return ret; } } return 0; } static int exynos_bcm_dbg_run(unsigned int bcm_run, struct exynos_bcm_dbg_data *data) { struct exynos_bcm_ipc_base_info ipc_base_info; int ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_RUN_CONT, BCM_EVT_SET, 0); ret = exynos_bcm_dbg_run_ctrl(&ipc_base_info, &bcm_run, data); if (ret) { BCM_ERR("%s: failed set Run state\n", __func__); return ret; } return 0; } void exynos_bcm_dbg_start(void) { int ret; if (!bcm_dbg_data) { BCM_ERR("%s: bcm_dbg_data is not ready!\n", __func__); return; } #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (!bcm_dbg_data->bcm_load_bin) { ret = exynos_bcm_dbg_load_bin(); if (ret) { BCM_ERR("%s failed to load BCM bin\n", __func__); return; } } #endif ret = exynos_bcm_dbg_run(BCM_RUN, bcm_dbg_data); if (ret) { BCM_ERR("%s: failed to bcm start\n", __func__); return; } BCM_INFO("%s\n", __func__); } EXPORT_SYMBOL(exynos_bcm_dbg_start); void exynos_bcm_dbg_stop(unsigned int bcm_stop_owner) { int ret; if (!bcm_dbg_data) { BCM_ERR("%s: bcm_dbg_data is not ready!\n", __func__); return; } #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (!bcm_dbg_data->bcm_load_bin) { BCM_ERR("BCM bin has not been loaded yet!!\n"); return; } #endif if (bcm_stop_owner >= STOP_OWNER_MAX) { BCM_ERR("Invalid stop owner (%u)\n", bcm_stop_owner); return; } if (!bcm_dbg_data->available_stop_owner[bcm_stop_owner]) { BCM_ERR("Have not stop permission (%u)\n", bcm_stop_owner); return; } ret = exynos_bcm_dbg_run(BCM_STOP, bcm_dbg_data); if (ret) { BCM_ERR("%s: failed to bcm stop\n", __func__); return; } BCM_INFO("%s\n", __func__); } EXPORT_SYMBOL(exynos_bcm_dbg_stop); static int exynos_bcm_dbg_str(unsigned int suspend, struct exynos_bcm_dbg_data *data) { struct exynos_bcm_ipc_base_info ipc_base_info; int ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_STR_STATE, BCM_EVT_SET, 0); ret = exynos_bcm_dbg_str_ctrl(&ipc_base_info, &suspend, data); if (ret) { BCM_ERR("%s:failed set str state\n", __func__); return ret; } return 0; } /* SYSFS Interface */ static ssize_t show_bcm_dbg_data_pd(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); int i; ssize_t count = 0; count += snprintf(buf, PAGE_SIZE, "=== IPC node info ===\n"); count += snprintf(buf + count, PAGE_SIZE, "IPC node name: %s\n", data->ipc_node->name); count += snprintf(buf + count, PAGE_SIZE, "\n=== Local Power Domain info ===\n"); count += snprintf(buf + count, PAGE_SIZE, "pd_size: %u, pd_sync_init: %s\n", data->pd_size, data->pd_sync_init ? "true" : "false"); for (i = 0; i < data->pd_size; i++) count += snprintf(buf + count, PAGE_SIZE, "pd_name: %12s, pd_index: %2u, pd_on: %s, cal_pdid: 0x%08x\n", data->pd_info[i]->pd_name, data->pd_info[i]->pd_index, data->pd_info[i]->on ? "true" : "false", data->pd_info[i]->cal_pdid); return count; } static ssize_t show_bcm_dbg_data_df_event(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); int i, j; ssize_t count = 0; count += snprintf(buf + count, PAGE_SIZE, "\n=== Pre-defined Event info ===\n"); for (i = 0; i < data->define_event_max; i++) { count += snprintf(buf + count, PAGE_SIZE, "Pre-defined Event index: %2u\n", data->define_event[i].index); for (j = 0; j < data->bcm_cnt_nr; j++) count += snprintf(buf + count, PAGE_SIZE, " Event[%d]: 0x%02x\n", j, data->define_event[i].event[j]); } count += snprintf(buf + count, PAGE_SIZE, "Default Pre-defined Event index: %2u\n", data->default_define_event); count += snprintf(buf + count, PAGE_SIZE, "Pre-defined Event Max: %2u\n", data->define_event_max); return count; } static ssize_t show_bcm_dbg_data_df_filter(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); int i, j; ssize_t count = 0; count += snprintf(buf + count, PAGE_SIZE, "\n=== Filter ID info ===\n"); for (i = 0; i < data->define_event_max; i++) { count += snprintf(buf + count, PAGE_SIZE, "Pre-defined Event index: %2u\n", data->define_event[i].index); count += snprintf(buf + count, PAGE_SIZE, " Filter ID mask: 0x%08x\n", data->define_filter_id[i].sm_id_mask); count += snprintf(buf + count, PAGE_SIZE, " Filter ID value: 0x%08x\n", data->define_filter_id[i].sm_id_value); count += snprintf(buf + count, PAGE_SIZE, " Filter ID active\n"); for (j = 0; j < data->bcm_cnt_nr; j++) count += snprintf(buf + count, PAGE_SIZE, " Event[%d]: %u\n", j, data->define_filter_id[i].sm_id_active[j]); } count += snprintf(buf + count, PAGE_SIZE, "\n=== Filter Others info ===\n"); for (i = 0; i < data->define_event_max; i++) { count += snprintf(buf + count, PAGE_SIZE, "Pre-defined Event index: %2u\n", data->define_event[i].index); for (j = 0; j < BCM_EVT_FLT_OTHR_MAX; j++) { count += snprintf(buf + count, PAGE_SIZE, " Filter Others type[%d]: 0x%02x\n", j, data->define_filter_others[i].sm_other_type[j]); count += snprintf(buf + count, PAGE_SIZE, " Filter Others mask[%d]: 0x%02x\n", j, data->define_filter_others[i].sm_other_mask[j]); count += snprintf(buf + count, PAGE_SIZE, " Filter Others value[%d]: 0x%02x\n", j, data->define_filter_others[i].sm_other_value[j]); } count += snprintf(buf + count, PAGE_SIZE, " Filter Others active\n"); for (j = 0; j < data->bcm_cnt_nr; j++) count += snprintf(buf + count, PAGE_SIZE, " Event[%d]: %u\n", j, data->define_filter_others[i].sm_other_active[j]); } return count; } static ssize_t show_bcm_dbg_data_df_sample(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); int i, j; ssize_t count = 0; count += snprintf(buf + count, PAGE_SIZE, "\n=== Sample ID info ===\n"); for (i = 0; i < data->define_event_max; i++) { count += snprintf(buf + count, PAGE_SIZE, "Pre-defined Event index: %2u\n", data->define_event[i].index); count += snprintf(buf + count, PAGE_SIZE, " Sample ID: peak_mask: 0x%08x\n", data->define_sample_id[i].peak_mask); count += snprintf(buf + count, PAGE_SIZE, " Sample ID: peak_id: 0x%08x\n", data->define_sample_id[i].peak_id); count += snprintf(buf + count, PAGE_SIZE, " Sample ID active\n"); for (j = 0; j < data->bcm_cnt_nr; j++) count += snprintf(buf + count, PAGE_SIZE, " Event[%d]: %u\n", j, data->define_sample_id[i].peak_enable[j]); } return count; } static ssize_t show_bcm_dbg_data_df_attr(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); int i; ssize_t count = 0; count += snprintf(buf + count, PAGE_SIZE, "\n=== Ctrl Attr info ===\n"); count += snprintf(buf + count, PAGE_SIZE, "Initial BCM run: %s\n", data->initial_bcm_run ? "true" : "false"); count += snprintf(buf + count, PAGE_SIZE, "Initial monitor period: %u msec\n", data->initial_period); count += snprintf(buf + count, PAGE_SIZE, "Initial BCM mode: %u\n", data->initial_bcm_mode); count += snprintf(buf + count, PAGE_SIZE, "Initial Run IPs\n"); for (i = 0; i < data->bcm_ip_nr; i++) count += snprintf(buf + count, PAGE_SIZE, " BCM IP[%d]: %s\n", i, data->initial_run_ip[i] ? "true" : "false"); return count; } static ssize_t show_get_event(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_event bcm_event; ssize_t count = 0; int ip_cnt, ev_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_event_ctrl(&ipc_base_info, &bcm_event, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get event(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]: def(%2u),", ip_cnt, bcm_event.index); for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) count += snprintf(buf + count, PAGE_SIZE, " (0x%02x),", bcm_event.event[ev_cnt]); count += snprintf(buf + count, PAGE_SIZE, "\n"); } return count; } static ssize_t show_event_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; /* help store_event_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= event_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [ip_range] [ip_index] [define_index] \ [ev0] [ev1] [ev2] [ev3] [ev4] [ev5] [ev6] [ev7] > \ event_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " ip_range: BCM_EACH(%d), BCM_ALL(%d)\n", BCM_EACH, BCM_ALL); count += snprintf(buf + count, PAGE_SIZE, " ip_index: number of bcm ip (0 ~ %u)\n" " (if ip_range is all, set to 0)\n", data->bcm_ip_nr - 1); count += snprintf(buf + count, PAGE_SIZE, " define_index: index of pre-defined event (0 ~ %u)\n" " 0 means no pre-defined event\n", data->define_event_max - 1); count += snprintf(buf + count, PAGE_SIZE, " evX: event value of counter (if define_index is not 0, \ set to 0\n" " event value should be hexa value\n"); return count; } static ssize_t store_event_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_event bcm_event; unsigned int bcm_ip_index = 0; unsigned int ip_range = 0; unsigned int event_id, defined_index; unsigned int *event; int ev_cnt, dfd_cnt, ret; event = kzalloc(sizeof(int) * data->bcm_cnt_nr, GFP_KERNEL); if (event == NULL) { BCM_ERR("%s: faild allocated of event memory\n", __func__); return -ENOMEM; } if (data->bcm_cnt_nr == 4) { ret = sscanf(buf, "%u %u %u %x %x %x %x", &ip_range, &bcm_ip_index, &defined_index, &event[0], &event[1], &event[2], &event[3]); } else if (data->bcm_cnt_nr == 8) { ret = sscanf(buf, "%u %u %u %x %x %x %x %x %x %x %x", &ip_range, &bcm_ip_index, &defined_index, &event[0], &event[1], &event[2], &event[3], &event[4], &event[5], &event[6], &event[7]); } else { BCM_ERR("%s: invalid bcm_cnt_nr\n", __func__); kfree(event); return -EINVAL; } /* 3 means is the number of index */ if (ret != data->bcm_cnt_nr + 3) { kfree(event); return -EINVAL; } ret = exynos_bcm_ip_validate(ip_range, bcm_ip_index, data->bcm_ip_nr); if (ret) { kfree(event); return ret; } if (defined_index >= data->define_event_max) { BCM_ERR("%s: Invalid defined index(%u)," " defined_max_nr(%u)\n", __func__, defined_index, data->define_event_max - 1); kfree(event); return -EINVAL; } if (ip_range == BCM_ALL) bcm_ip_index = 0; if (defined_index != NO_PRE_DEFINE_EVT) { event_id = BCM_EVT_PRE_DEFINE; for (dfd_cnt = 1; dfd_cnt < data->define_event_max; dfd_cnt++) { if (defined_index == data->define_event[dfd_cnt].index) break; } bcm_event.index = data->define_event[dfd_cnt].index; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) bcm_event.event[ev_cnt] = data->define_event[dfd_cnt].event[ev_cnt]; } else { event_id = BCM_EVT_EVENT; bcm_event.index = NO_PRE_DEFINE_EVT; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) bcm_event.event[ev_cnt] = event[ev_cnt]; } exynos_bcm_dbg_set_base_info(&ipc_base_info, event_id, BCM_EVT_SET, ip_range); ret = exynos_bcm_dbg_event_ctrl(&ipc_base_info, &bcm_event, bcm_ip_index, data); if (ret) { BCM_ERR("%s:failed set event\n", __func__); kfree(event); return ret; } kfree(event); return count; } static ssize_t show_get_filter_id(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_filter_id filter_id; ssize_t count = 0; int ip_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_ID, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_filter_id_ctrl(&ipc_base_info, &filter_id, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get filter id(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]: mask(0x%08x), value(0x%08x)\n", ip_cnt, filter_id.sm_id_mask, filter_id.sm_id_value); } return count; } static ssize_t show_get_filter_id_active(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_filter_id filter_id; ssize_t count = 0; int ip_cnt, ev_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_ID, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_filter_id_ctrl(&ipc_base_info, &filter_id, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get filter id(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]:", ip_cnt); for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) count += snprintf(buf + count, PAGE_SIZE, " ev%d %u,", ev_cnt, filter_id.sm_id_active[ev_cnt]); count += snprintf(buf + count, PAGE_SIZE, "\n"); } return count; } static ssize_t show_filter_id_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; /* help store_filter_id_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= filter_id_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [ip_range] [ip_index] [define_index] [mask] [value] \ [ev0] [ev1] [ev2] [ev3] [ev4] [ev5] [ev6] [ev7] > \ filter_id_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " ip_range: BCM_EACH(%d), BCM_ALL(%d)\n", BCM_EACH, BCM_ALL); count += snprintf(buf + count, PAGE_SIZE, " ip_index: number of bcm ip (0 ~ %u)\n" " (if ip_range is all, set to 0)\n", data->bcm_ip_nr - 1); count += snprintf(buf + count, PAGE_SIZE, " define_index: index of pre-defined event (0 ~ %u)\n" " 0 means no pre-defined event\n", data->define_event_max - 1); count += snprintf(buf + count, PAGE_SIZE, " mask: masking for filter id (if define_index is not 0, \ set to 0)\n" " mask value should be hexa value\n"); count += snprintf(buf + count, PAGE_SIZE, " value: value of filter id (if define_index is not 0, set to 0)\n" " value should be hexa value\n"); count += snprintf(buf + count, PAGE_SIZE, " evX: event counter alloc for filter id \ (if define_index is not 0, set to 0)\n" " value should be 0 or 1\n"); return count; } static ssize_t store_filter_id_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_filter_id filter_id; unsigned int bcm_ip_index = 0; unsigned int ip_range = 0; unsigned int defined_index; unsigned int sm_id_mask, sm_id_value; unsigned int *sm_id_active; int ev_cnt, ret; sm_id_active = kzalloc(sizeof(int) * data->bcm_cnt_nr, GFP_KERNEL); if (sm_id_active == NULL) { BCM_ERR("%s: faild allocated of sm_id_active memory\n", __func__); return -ENOMEM; } if (data->bcm_cnt_nr == 4) { ret = sscanf(buf, "%u %u %u %x %x %u %u %u %u", &ip_range, &bcm_ip_index, &defined_index, &sm_id_mask, &sm_id_value, &sm_id_active[0], &sm_id_active[1], &sm_id_active[2], &sm_id_active[3]); } else if (data->bcm_cnt_nr == 8) { ret = sscanf(buf, "%u %u %u %x %x %u %u %u %u %u %u %u %u", &ip_range, &bcm_ip_index, &defined_index, &sm_id_mask, &sm_id_value, &sm_id_active[0], &sm_id_active[1], &sm_id_active[2], &sm_id_active[3], &sm_id_active[4], &sm_id_active[5], &sm_id_active[6], &sm_id_active[7]); } else { BCM_ERR("%s: invalid bcm_cnt_nr\n", __func__); kfree(sm_id_active); return -EINVAL; } /* 5 --> the number of index */ if (ret != data->bcm_cnt_nr + 5) { kfree(sm_id_active); return -EINVAL; } ret = exynos_bcm_ip_validate(ip_range, bcm_ip_index, data->bcm_ip_nr); if (ret) { kfree(sm_id_active); return ret; } for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) { if (sm_id_active[ev_cnt]) sm_id_active[ev_cnt] = true; } if (defined_index >= data->define_event_max) { BCM_ERR("%s: Invalid defined index(%u)," " defined_max_nr(%u)\n", __func__, defined_index, data->define_event_max - 1); kfree(sm_id_active); return -EINVAL; } if (ip_range == BCM_ALL) bcm_ip_index = 0; if (defined_index != NO_PRE_DEFINE_EVT) { filter_id.sm_id_mask = data->define_filter_id[defined_index].sm_id_mask; filter_id.sm_id_value = data->define_filter_id[defined_index].sm_id_value; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) filter_id.sm_id_active[ev_cnt] = data->define_filter_id[defined_index].sm_id_active[ev_cnt]; } else { filter_id.sm_id_mask = sm_id_mask; filter_id.sm_id_value = sm_id_value; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) filter_id.sm_id_active[ev_cnt] = sm_id_active[ev_cnt]; } exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_ID, BCM_EVT_SET, ip_range); ret = exynos_bcm_dbg_filter_id_ctrl(&ipc_base_info, &filter_id, bcm_ip_index, data); if (ret) { BCM_ERR("%s:failed set filter ID\n", __func__); kfree(sm_id_active); return ret; } kfree(sm_id_active); return count; } static ssize_t show_get_filter_others(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_filter_others filter_others; ssize_t count = 0; int ip_cnt, othr_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_OTHERS, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_filter_others_ctrl(&ipc_base_info, &filter_others, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get filter others(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]:", ip_cnt); for (othr_cnt = 0; othr_cnt < BCM_EVT_FLT_OTHR_MAX; othr_cnt++) count += snprintf(buf + count, PAGE_SIZE, " type%d(0x%02x), mask%d(0x%02x), value%d(0x%02x),", othr_cnt, filter_others.sm_other_type[othr_cnt], othr_cnt, filter_others.sm_other_mask[othr_cnt], othr_cnt, filter_others.sm_other_value[othr_cnt]); count += snprintf(buf + count, PAGE_SIZE, "\n"); } return count; } static ssize_t show_get_filter_others_active(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_filter_others filter_others; ssize_t count = 0; int ip_cnt, ev_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_OTHERS, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_filter_others_ctrl(&ipc_base_info, &filter_others, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get filter others(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]:", ip_cnt); for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) count += snprintf(buf + count, PAGE_SIZE, " ev%d %u,", ev_cnt, filter_others.sm_other_active[ev_cnt]); count += snprintf(buf + count, PAGE_SIZE, "\n"); } return count; } static ssize_t show_filter_others_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; int othr_cnt; /* help store_filter_others_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= filter_others_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [ip_range] [ip_index] [define_index] \ [type0] [mask0] [value0] [type1] [mask1] [value1] \ [ev0] [ev1] [ev2] [ev3] [ev4] [ev5] [ev6] [ev7] > \ filter_others_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " ip_range: BCM_EACH(%d), BCM_ALL(%d)\n", BCM_EACH, BCM_ALL); count += snprintf(buf + count, PAGE_SIZE, " ip_index: number of bcm ip (0 ~ %u)\n" " (if ip_range is all, set to 0)\n", data->bcm_ip_nr - 1); count += snprintf(buf + count, PAGE_SIZE, " define_index: index of pre-defined event (0 ~ %u)\n" " 0 means no pre-defined event\n", data->define_event_max - 1); for (othr_cnt = 0; othr_cnt < BCM_EVT_FLT_OTHR_MAX; othr_cnt++) { count += snprintf(buf + count, PAGE_SIZE, " type%d: type%d for filter others \ (if define_index is not 0, set to 0)\n" " type%d value should be hexa value\n", othr_cnt, othr_cnt, othr_cnt); count += snprintf(buf + count, PAGE_SIZE, " mask%d: mask%d for filter others \ (if define_index is not 0, set to 0)\n" " mask%d value should be hexa value\n", othr_cnt, othr_cnt, othr_cnt); count += snprintf(buf + count, PAGE_SIZE, " value%d: value%d of filter others \ (if define_index is not 0, set to 0)\n" " value%d should be hexa value\n", othr_cnt, othr_cnt, othr_cnt); } count += snprintf(buf + count, PAGE_SIZE, " evX: event counter alloc for filter others \ (if define_index is not 0, set to 0)\n" " value should be 0 or 1\n"); return count; } static ssize_t store_filter_others_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_filter_others filter_others; unsigned int bcm_ip_index = 0; unsigned int ip_range = 0; unsigned int defined_index; unsigned int sm_other_type[BCM_EVT_FLT_OTHR_MAX]; unsigned int sm_other_mask[BCM_EVT_FLT_OTHR_MAX]; unsigned int sm_other_value[BCM_EVT_FLT_OTHR_MAX]; unsigned int *sm_other_active; int ev_cnt, othr_cnt, ret; sm_other_active = kzalloc(sizeof(int) * data->bcm_cnt_nr, GFP_KERNEL); if (sm_other_active == NULL) { BCM_ERR("%s: faild allocated of sm_other_active memory\n", __func__); return -ENOMEM; } if (data->bcm_cnt_nr == 4) { ret = sscanf(buf, "%u %u %u %x %x %x %x %x %x %u %u %u %u", &ip_range, &bcm_ip_index, &defined_index, &sm_other_type[0], &sm_other_mask[0], &sm_other_value[0], &sm_other_type[1], &sm_other_mask[1], &sm_other_value[1], &sm_other_active[0], &sm_other_active[1], &sm_other_active[2], &sm_other_active[3]); } else if (data->bcm_cnt_nr == 8) { ret = sscanf(buf, "%u %u %u %x %x %x %x %x %x %u %u %u %u %u %u %u %u", &ip_range, &bcm_ip_index, &defined_index, &sm_other_type[0], &sm_other_mask[0], &sm_other_value[0], &sm_other_type[1], &sm_other_mask[1], &sm_other_value[1], &sm_other_active[0], &sm_other_active[1], &sm_other_active[2], &sm_other_active[3], &sm_other_active[4], &sm_other_active[5], &sm_other_active[6], &sm_other_active[7]); } else { BCM_ERR("%s: invalid bcm_cnt_nr\n", __func__); kfree(sm_other_active); return -EINVAL; } /* 9 --> the number of index */ if (ret != data->bcm_cnt_nr + 9) { kfree(sm_other_active); return -EINVAL; } ret = exynos_bcm_ip_validate(ip_range, bcm_ip_index, data->bcm_ip_nr); if (ret) { kfree(sm_other_active); return ret; } for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) { if (sm_other_active[ev_cnt]) sm_other_active[ev_cnt] = true; } if (defined_index >= data->define_event_max) { BCM_ERR("%s: Invalid defined index(%u)," " defined_max_nr(%u)\n", __func__, defined_index, data->define_event_max - 1); kfree(sm_other_active); return -EINVAL; } if (ip_range == BCM_ALL) bcm_ip_index = 0; if (defined_index != NO_PRE_DEFINE_EVT) { for (othr_cnt = 0; othr_cnt < BCM_EVT_FLT_OTHR_MAX; othr_cnt++) { filter_others.sm_other_type[othr_cnt] = data->define_filter_others[defined_index].sm_other_type[othr_cnt]; filter_others.sm_other_mask[othr_cnt] = data->define_filter_others[defined_index].sm_other_mask[othr_cnt]; filter_others.sm_other_value[othr_cnt] = data->define_filter_others[defined_index].sm_other_value[othr_cnt]; } for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) filter_others.sm_other_active[ev_cnt] = data->define_filter_others[defined_index].sm_other_active[ev_cnt]; } else { for (othr_cnt = 0; othr_cnt < BCM_EVT_FLT_OTHR_MAX; othr_cnt++) { filter_others.sm_other_type[othr_cnt] = sm_other_type[othr_cnt]; filter_others.sm_other_mask[othr_cnt] = sm_other_mask[othr_cnt]; filter_others.sm_other_value[othr_cnt] = sm_other_value[othr_cnt]; } for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) filter_others.sm_other_active[ev_cnt] = sm_other_active[ev_cnt]; } exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_FLT_OTHERS, BCM_EVT_SET, ip_range); ret = exynos_bcm_dbg_filter_others_ctrl(&ipc_base_info, &filter_others, bcm_ip_index, data); if (ret) { BCM_ERR("%s:failed set filter others\n", __func__); kfree(sm_other_active); return ret; } kfree(sm_other_active); return count; } static ssize_t show_get_sample_id(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_sample_id sample_id; ssize_t count = 0; int ip_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_SAMPLE_ID, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_sample_id_ctrl(&ipc_base_info, &sample_id, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get sample id(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]: mask(0x%08x), id(0x%08x)\n", ip_cnt, sample_id.peak_mask, sample_id.peak_id); } return count; } static ssize_t show_get_sample_id_active(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_sample_id sample_id; ssize_t count = 0; int ip_cnt, ev_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_SAMPLE_ID, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_sample_id_ctrl(&ipc_base_info, &sample_id, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get sample id(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]:", ip_cnt); for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) count += snprintf(buf + count, PAGE_SIZE, " ev%d %u,", ev_cnt, sample_id.peak_enable[ev_cnt]); count += snprintf(buf + count, PAGE_SIZE, "\n"); } return count; } static ssize_t show_sample_id_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; /* help store_sample_id_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= sample_id_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [ip_range] [ip_index] [define_index] [mask] [id] \ [ev0] [ev1] [ev2] [ev3] [ev4] [ev5] [ev6] [ev7] > \ sample_id_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " ip_range: BCM_EACH(%d), BCM_ALL(%d)\n", BCM_EACH, BCM_ALL); count += snprintf(buf + count, PAGE_SIZE, " ip_index: number of bcm ip (0 ~ %u)\n" " (if ip_range is all, set to 0)\n", data->bcm_ip_nr - 1); count += snprintf(buf + count, PAGE_SIZE, " define_index: index of pre-defined event (0 ~ %u)\n" " 0 means no pre-defined event\n", data->define_event_max - 1); count += snprintf(buf + count, PAGE_SIZE, " mask: masking for sample id \ (if define_index is not 0, set to 0)\n" " mask value should be hexa value\n"); count += snprintf(buf + count, PAGE_SIZE, " id: id of sample id \ (if define_index is not 0, set to 0)\n" " id should be hexa value\n"); count += snprintf(buf + count, PAGE_SIZE, " evX: event counter enable for sample id \ (if define_index is not 0, set to 0)\n" " value should be 0 or 1\n"); return count; } static ssize_t store_sample_id_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; struct exynos_bcm_sample_id sample_id; unsigned int bcm_ip_index = 0; unsigned int ip_range = 0; unsigned int defined_index; unsigned int peak_mask, peak_id; unsigned int *peak_enable; int ev_cnt, ret; peak_enable = kzalloc(sizeof(int) * data->bcm_cnt_nr, GFP_KERNEL); if (peak_enable == NULL) { BCM_ERR("%s: faild allocated of peak_enable memory\n", __func__); return -ENOMEM; } if (data->bcm_cnt_nr == 4) { ret = sscanf(buf, "%u %u %u %x %x %u %u %u %u", &ip_range, &bcm_ip_index, &defined_index, &peak_mask, &peak_id, &peak_enable[0], &peak_enable[1], &peak_enable[2], &peak_enable[3]); } else if (data->bcm_cnt_nr == 8) { ret = sscanf(buf, "%u %u %u %x %x %u %u %u %u %u %u %u %u", &ip_range, &bcm_ip_index, &defined_index, &peak_mask, &peak_id, &peak_enable[0], &peak_enable[1], &peak_enable[2], &peak_enable[3], &peak_enable[4], &peak_enable[5], &peak_enable[6], &peak_enable[7]); } else { BCM_ERR("%s: invalid bcm_cnt_nr\n", __func__); kfree(peak_enable); return -EINVAL; } /* 5 --> the number of index */ if (ret != data->bcm_cnt_nr + 5) { kfree(peak_enable); return -EINVAL; } ret = exynos_bcm_ip_validate(ip_range, bcm_ip_index, data->bcm_ip_nr); if (ret) { kfree(peak_enable); return ret; } for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) { if (peak_enable[ev_cnt]) peak_enable[ev_cnt] = true; } if (defined_index >= data->define_event_max) { BCM_ERR("%s: Invalid defined index(%u)," " defined_max_nr(%u)\n", __func__, defined_index, data->define_event_max - 1); kfree(peak_enable); return -EINVAL; } if (ip_range == BCM_ALL) bcm_ip_index = 0; if (defined_index != NO_PRE_DEFINE_EVT) { sample_id.peak_mask = data->define_sample_id[defined_index].peak_mask; sample_id.peak_id = data->define_sample_id[defined_index].peak_id; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) sample_id.peak_enable[ev_cnt] = data->define_sample_id[defined_index].peak_enable[ev_cnt]; } else { sample_id.peak_mask = peak_mask; sample_id.peak_id = peak_id; for (ev_cnt = 0; ev_cnt < data->bcm_cnt_nr; ev_cnt++) sample_id.peak_enable[ev_cnt] = peak_enable[ev_cnt]; } exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_EVENT_SAMPLE_ID, BCM_EVT_SET, ip_range); ret = exynos_bcm_dbg_sample_id_ctrl(&ipc_base_info, &sample_id, bcm_ip_index, data); if (ret) { BCM_ERR("%s:failed set sample ID\n", __func__); kfree(peak_enable); return ret; } kfree(peak_enable); return count; } static ssize_t show_get_run(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int bcm_run; ssize_t count = 0; int ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_RUN_CONT, BCM_EVT_GET, 0); ret = exynos_bcm_dbg_run_ctrl(&ipc_base_info, &bcm_run, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get run state\n"); return count; } count += snprintf(buf + count, PAGE_SIZE, "run state: raw state(%s), sw state(%s)\n", bcm_run ? "run" : "stop", data->bcm_run_state ? "run" : "stop"); return count; } static ssize_t show_run_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; /* help store_run_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= run_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [run_state] > run_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " run_state: BCM_RUN(%d), BCM_STOP(%d)\n", BCM_RUN, BCM_STOP); return count; } static ssize_t store_run_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); unsigned int bcm_run; int ret; ret = kstrtouint(buf, 0, &bcm_run); if (ret) return ret; if (!(bcm_run == 0 || bcm_run == 1)) { BCM_ERR("%s: invalid parameter (%u)\n", __func__, bcm_run); return -EINVAL; } if (bcm_run) bcm_run = true; ret = exynos_bcm_dbg_run(bcm_run, data); if (ret) { BCM_ERR("%s:failed set Run state\n", __func__); return ret; } return count; } static ssize_t show_get_period(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int period; ssize_t count = 0; int ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_PERIOD_CONT, BCM_EVT_GET, 0); ret = exynos_bcm_dbg_period_ctrl(&ipc_base_info, &period, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get period\n"); return count; } count += snprintf(buf + count, PAGE_SIZE, "monitor period: %u msec\n", period); return count; } static ssize_t show_period_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; /* help store_period_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= period_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [period] > period_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " period: monitor period (unit: msec), \ min(%d msec) ~ max(%d msec)\n", BCM_TIMER_PERIOD_MIN, BCM_TIMER_PERIOD_MAX); return count; } static ssize_t store_period_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int period; int ret; ret = kstrtouint(buf, 0, &period); if (ret) return ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_PERIOD_CONT, BCM_EVT_SET, 0); ret = exynos_bcm_dbg_period_ctrl(&ipc_base_info, &period, data); if (ret) { BCM_ERR("%s:failed set period\n", __func__); return ret; } return count; } static ssize_t show_get_mode(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int bcm_mode; ssize_t count = 0; int ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_MODE_CONT, BCM_EVT_GET, 0); ret = exynos_bcm_dbg_mode_ctrl(&ipc_base_info, &bcm_mode, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get mode\n"); return count; } count += snprintf(buf + count, PAGE_SIZE, "mode: %d (%d:Interval, %d:Once, %d:User_ctrl)\n", bcm_mode, BCM_MODE_INTERVAL, BCM_MODE_ONCE, BCM_MODE_USERCTRL); return count; } static ssize_t show_mode_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; /* help store_mode_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= mode_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [mode] > mode_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " mode: Interval(%d), Once(%d), User_ctrl(%d)\n", BCM_MODE_INTERVAL, BCM_MODE_ONCE, BCM_MODE_USERCTRL); return count; } static ssize_t store_mode_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int bcm_mode; int ret; ret = kstrtouint(buf, 0, &bcm_mode); if (ret) return ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_MODE_CONT, BCM_EVT_SET, 0); ret = exynos_bcm_dbg_mode_ctrl(&ipc_base_info, &bcm_mode, data); if (ret) { BCM_ERR("%s:failed set mode\n", __func__); return ret; } return count; } static ssize_t show_get_str(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int suspend; ssize_t count = 0; int ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_STR_STATE, BCM_EVT_GET, 0); ret = exynos_bcm_dbg_str_ctrl(&ipc_base_info, &suspend, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get str state\n"); return count; } count += snprintf(buf + count, PAGE_SIZE, "str state: %s\n", suspend ? "suspend" : "resume"); return count; } static ssize_t show_str_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; /* help store_str_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= str_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [str_state] > str_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " str_state: suspend(1), resume(0)\n"); return count; } static ssize_t store_str_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); unsigned int suspend; int ret; ret = kstrtouint(buf, 0, &suspend); if (ret) return ret; if (suspend) suspend = true; ret = exynos_bcm_dbg_str(suspend, data); if (ret) { BCM_ERR("%s:failed set str state\n", __func__); return ret; } return count; } static ssize_t show_get_ip(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int ip_enable; ssize_t count = 0; int ip_cnt, ret; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_IP_CONT, BCM_EVT_GET, BCM_EACH); for (ip_cnt = 0; ip_cnt < data->bcm_ip_nr; ip_cnt++) { ret = exynos_bcm_dbg_ip_ctrl(&ipc_base_info, &ip_enable, ip_cnt, data); if (ret) { count += snprintf(buf + count, PAGE_SIZE, "failed get ip_enable state(ip:%d)\n", ip_cnt); return count; } count += snprintf(buf + count, PAGE_SIZE, "bcm[%2d]: enabled (%s)\n", ip_cnt, ip_enable ? "true" : "false"); } return count; } static ssize_t show_ip_ctrl_help(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; /* help store_ip_ctrl */ count += snprintf(buf + count, PAGE_SIZE, "\n= ip_ctrl set help =\n"); count += snprintf(buf + count, PAGE_SIZE, "Usage:\n"); count += snprintf(buf + count, PAGE_SIZE, "echo [ip_index] [enable] > ip_ctrl\n"); count += snprintf(buf + count, PAGE_SIZE, " ip_index: number of bcm ip (0 ~ %u)\n", data->bcm_ip_nr - 1); count += snprintf(buf + count, PAGE_SIZE, " enable: ip enable state (1:enable, 0:disable)\n"); return count; } static ssize_t store_ip_ctrl(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); struct exynos_bcm_ipc_base_info ipc_base_info; unsigned int bcm_ip_index, ip_enable; int ret; ret = sscanf(buf, "%u %u", &bcm_ip_index, &ip_enable); if (ret != 2) return -EINVAL; ret = exynos_bcm_ip_validate(BCM_EACH, bcm_ip_index, data->bcm_ip_nr); if (ret) return ret; if (ip_enable) ip_enable = true; exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_IP_CONT, BCM_EVT_SET, BCM_EACH); ret = exynos_bcm_dbg_ip_ctrl(&ipc_base_info, &ip_enable, bcm_ip_index, data); if (ret) { BCM_ERR("%s:failed set IP control\n", __func__); return ret; } return count; } #ifdef CONFIG_DEBUG_SNAPSHOT static int exynos_bcm_dbg_set_dump_info(struct exynos_bcm_dbg_data *data) { struct exynos_bcm_ipc_base_info ipc_base_info; int ret; if (data->dump_addr.buff_size == 0 || data->dump_addr.buff_size > data->dump_addr.p_size) data->dump_addr.buff_size = data->dump_addr.p_size; BCM_INFO("%s: virtual address for reserved memory: v_addr = 0x%p\n", __func__, data->dump_addr.v_addr); BCM_INFO("%s: buffer size for reserved memory: buff_size = 0x%x\n", __func__, data->dump_addr.buff_size); /* send physical address info to BCM plugin */ exynos_bcm_dbg_set_base_info(&ipc_base_info, BCM_EVT_DUMP_ADDR, BCM_EVT_SET, 0); ret = exynos_bcm_dbg_dump_addr_ctrl(&ipc_base_info, &data->dump_addr, data); if (ret) { BCM_ERR("%s: failed set dump address info\n", __func__); return ret; } return 0; } static ssize_t show_dump_addr_info(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; count += snprintf(buf + count, PAGE_SIZE, "\n= BCM dump address info =\n"); count += snprintf(buf + count, PAGE_SIZE, "physical address = 0x%08x\n", data->dump_addr.p_addr); count += snprintf(buf + count, PAGE_SIZE, "virtual address = 0x%p\n", data->dump_addr.v_addr); count += snprintf(buf + count, PAGE_SIZE, "dump region size = 0x%08x\n", data->dump_addr.p_size); count += snprintf(buf + count, PAGE_SIZE, "actual use size = 0x%08x\n", data->dump_addr.buff_size); return count; } static ssize_t store_dump_addr_info(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); unsigned int buff_size; int ret; ret = kstrtouint(buf, 16, &buff_size); if (ret) return ret; data->dump_addr.buff_size = buff_size; ret = exynos_bcm_dbg_set_dump_info(data); if (ret) { BCM_ERR("%s: failed set dump info\n", __func__); return ret; } return count; } #endif static ssize_t show_enable_dump_klog(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; count += snprintf(buf + count, PAGE_SIZE, "\n= BCM dump to kernel log =\n"); count += snprintf(buf + count, PAGE_SIZE, "%s\n", data->dump_klog ? "enabled" : "disabled"); return count; } static ssize_t store_enable_dump_klog(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); unsigned int enable; int ret; ret = kstrtouint(buf, 0, &enable); if (ret) return ret; if (enable) data->dump_klog = true; else data->dump_klog = false; return count; } static ssize_t show_enable_stop_owner(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; int i; count += snprintf(buf + count, PAGE_SIZE, "\n= BCM Available stop owner =\n"); for (i = 0; i < STOP_OWNER_MAX; i++) count += snprintf(buf + count, PAGE_SIZE, " stop owner[%d]: %s\n", i, data->available_stop_owner[i] ? "true" : "false"); return count; } static ssize_t store_enable_stop_owner(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); unsigned int owner_index, enable; int ret; ret = sscanf(buf, "%u %u", &owner_index, &enable); if (ret != 2) return -EINVAL; if (owner_index >= STOP_OWNER_MAX) { BCM_ERR("Invalid stop owner (%u)\n", owner_index); return -EINVAL; } if (enable) data->available_stop_owner[owner_index] = true; else data->available_stop_owner[owner_index] = false; return count; } #ifdef CONFIG_EXYNOS_BCM_DBG_GNR static ssize_t show_bcm_dbg_load_bin(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); ssize_t count = 0; count += snprintf(buf + count, PAGE_SIZE, "\n= BCM Load Bin =\n"); count += snprintf(buf + count, PAGE_SIZE, " bcm load bin: %s\n", data->bcm_load_bin ? "true" : "false"); return count; } static ssize_t store_bcm_dbg_load_bin(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned int load; int ret; ret = kstrtouint(buf, 0, &load); if (ret) return ret; /* loading firmware */ if (load) { ret = exynos_bcm_dbg_load_bin(); if (ret) { BCM_ERR("%s: failed to load BCM bin\n", __func__); return ret; } } return count; } #endif static DEVICE_ATTR(bcm_dbg_data_pd, 0440, show_bcm_dbg_data_pd, NULL); static DEVICE_ATTR(bcm_dbg_data_df_event, 0440, show_bcm_dbg_data_df_event, NULL); static DEVICE_ATTR(bcm_dbg_data_df_filter, 0440, show_bcm_dbg_data_df_filter, NULL); static DEVICE_ATTR(bcm_dbg_data_df_sample, 0440, show_bcm_dbg_data_df_sample, NULL); static DEVICE_ATTR(bcm_dbg_data_df_attr, 0440, show_bcm_dbg_data_df_attr, NULL); static DEVICE_ATTR(get_event, 0440, show_get_event, NULL); static DEVICE_ATTR(event_ctrl_help, 0440, show_event_ctrl_help, NULL); static DEVICE_ATTR(event_ctrl, 0640, NULL, store_event_ctrl); static DEVICE_ATTR(get_filter_id, 0440, show_get_filter_id, NULL); static DEVICE_ATTR(get_filter_id_active, 0440, show_get_filter_id_active, NULL); static DEVICE_ATTR(filter_id_ctrl_help, 0440, show_filter_id_ctrl_help, NULL); static DEVICE_ATTR(filter_id_ctrl, 0640, NULL, store_filter_id_ctrl); static DEVICE_ATTR(get_filter_others, 0440, show_get_filter_others, NULL); static DEVICE_ATTR(get_filter_others_active, 0440, show_get_filter_others_active, NULL); static DEVICE_ATTR(filter_others_ctrl_help, 0440, show_filter_others_ctrl_help, NULL); static DEVICE_ATTR(filter_others_ctrl, 0640, NULL, store_filter_others_ctrl); static DEVICE_ATTR(get_sample_id, 0440, show_get_sample_id, NULL); static DEVICE_ATTR(get_sample_id_active, 0440, show_get_sample_id_active, NULL); static DEVICE_ATTR(sample_id_ctrl_help, 0440, show_sample_id_ctrl_help, NULL); static DEVICE_ATTR(sample_id_ctrl, 0640, NULL, store_sample_id_ctrl); static DEVICE_ATTR(get_run, 0440, show_get_run, NULL); static DEVICE_ATTR(run_ctrl_help, 0440, show_run_ctrl_help, NULL); static DEVICE_ATTR(run_ctrl, 0640, NULL, store_run_ctrl); static DEVICE_ATTR(get_period, 0440, show_get_period, NULL); static DEVICE_ATTR(period_ctrl_help, 0440, show_period_ctrl_help, NULL); static DEVICE_ATTR(period_ctrl, 0640, NULL, store_period_ctrl); static DEVICE_ATTR(get_mode, 0440, show_get_mode, NULL); static DEVICE_ATTR(mode_ctrl_help, 0440, show_mode_ctrl_help, NULL); static DEVICE_ATTR(mode_ctrl, 0640, NULL, store_mode_ctrl); static DEVICE_ATTR(get_str, 0440, show_get_str, NULL); static DEVICE_ATTR(str_ctrl_help, 0440, show_str_ctrl_help, NULL); static DEVICE_ATTR(str_ctrl, 0640, NULL, store_str_ctrl); static DEVICE_ATTR(get_ip, 0440, show_get_ip, NULL); static DEVICE_ATTR(ip_ctrl_help, 0440, show_ip_ctrl_help, NULL); static DEVICE_ATTR(ip_ctrl, 0640, NULL, store_ip_ctrl); #ifdef CONFIG_DEBUG_SNAPSHOT static DEVICE_ATTR(dump_addr_info, 0640, show_dump_addr_info, store_dump_addr_info); #endif static DEVICE_ATTR(enable_dump_klog, 0640, show_enable_dump_klog, store_enable_dump_klog); static DEVICE_ATTR(enable_stop_owner, 0640, show_enable_stop_owner, store_enable_stop_owner); #ifdef CONFIG_EXYNOS_BCM_DBG_GNR static DEVICE_ATTR(bcm_dbg_load_bin, 0640, show_bcm_dbg_load_bin, store_bcm_dbg_load_bin); #endif static struct attribute *exynos_bcm_dbg_sysfs_entries[] = { &dev_attr_bcm_dbg_data_pd.attr, &dev_attr_bcm_dbg_data_df_event.attr, &dev_attr_bcm_dbg_data_df_filter.attr, &dev_attr_bcm_dbg_data_df_sample.attr, &dev_attr_bcm_dbg_data_df_attr.attr, &dev_attr_get_event.attr, &dev_attr_event_ctrl_help.attr, &dev_attr_event_ctrl.attr, &dev_attr_get_filter_id.attr, &dev_attr_get_filter_id_active.attr, &dev_attr_filter_id_ctrl_help.attr, &dev_attr_filter_id_ctrl.attr, &dev_attr_get_filter_others.attr, &dev_attr_get_filter_others_active.attr, &dev_attr_filter_others_ctrl_help.attr, &dev_attr_filter_others_ctrl.attr, &dev_attr_get_sample_id.attr, &dev_attr_get_sample_id_active.attr, &dev_attr_sample_id_ctrl_help.attr, &dev_attr_sample_id_ctrl.attr, &dev_attr_get_run.attr, &dev_attr_run_ctrl_help.attr, &dev_attr_run_ctrl.attr, &dev_attr_get_period.attr, &dev_attr_period_ctrl_help.attr, &dev_attr_period_ctrl.attr, &dev_attr_get_mode.attr, &dev_attr_mode_ctrl_help.attr, &dev_attr_mode_ctrl.attr, &dev_attr_get_str.attr, &dev_attr_str_ctrl_help.attr, &dev_attr_str_ctrl.attr, &dev_attr_get_ip.attr, &dev_attr_ip_ctrl_help.attr, &dev_attr_ip_ctrl.attr, #ifdef CONFIG_DEBUG_SNAPSHOT &dev_attr_dump_addr_info.attr, #endif &dev_attr_enable_dump_klog.attr, &dev_attr_enable_stop_owner.attr, #ifdef CONFIG_EXYNOS_BCM_DBG_GNR &dev_attr_bcm_dbg_load_bin.attr, #endif NULL, }; static struct attribute_group exynos_bcm_dbg_attr_group = { .name = "bcm_attr", .attrs = exynos_bcm_dbg_sysfs_entries, }; #ifdef CONFIG_DEBUG_SNAPSHOT static int exynos_bcm_dbg_dump_config(struct exynos_bcm_dbg_data *data) { int ret; data->dump_addr.p_addr = dbg_snapshot_get_item_paddr(BCM_DSS_NAME); data->dump_addr.p_size = dbg_snapshot_get_item_size(BCM_DSS_NAME); data->dump_addr.v_addr = (void __iomem *)dbg_snapshot_get_item_vaddr(BCM_DSS_NAME); ret = exynos_bcm_dbg_set_dump_info(data); if (ret) { BCM_ERR("%s: failed set dump info\n", __func__); return ret; } return 0; } #endif #ifdef CONFIG_EXYNOS_ITMON static int exynos_bcm_dbg_itmon_notifier(struct notifier_block *nb, unsigned long val, void *v) { struct itmon_notifier *itmon_info = (struct itmon_notifier *)v; BCM_INFO("%s: itmon error code %u\n", __func__, itmon_info->errcode); if (itmon_info->errcode == ERRCODE_ITMON_TIMEOUT) { BCM_INFO("%s: Note: It can occurred be IPC timeout \ because can be trying access to timeout block \ from BCMDBG plugin\n", __func__); exynos_bcm_dbg_stop(ITMON_HANDLE); } return NOTIFY_OK; } #endif static int exynos_bcm_dbg_init(struct exynos_bcm_dbg_data *data) { int ret = 0; /* parsing dts data for BCM debug */ ret = exynos_bcm_dbg_parse_dt(data->dev->of_node, data); if (ret) { BCM_ERR("%s: failed to parse private data\n", __func__); goto err_parse_dt; } /* Request IPC channel */ ret = exynos_bcm_dbg_ipc_channel_request(data); if (ret) { BCM_ERR("%s: failed to ipc channel request\n", __func__); goto err_ipc_channel; } /* Initalize BCM Plugin */ ret = exynos_bcm_dbg_early_init(data); if (ret) { BCM_ERR("%s: failed to early bcm initialize\n", __func__); goto err_early_init; } /* initial Local Power Domain sync-up */ data->pd_sync_init = false; ret = exynos_bcm_dbg_pd_sync_init(data); if (ret) { BCM_ERR("%s: failed to pd_sync_init\n", __func__); goto err_pd_sync_init; } #ifdef CONFIG_DEBUG_SNAPSHOT ret = exynos_bcm_dbg_dump_config(data); if (ret) { BCM_ERR("%s: failed to dump config\n", __func__); goto err_dump_config; } #endif data->dump_klog = false; /* BCM plugin run */ if (data->initial_bcm_run) { ret = exynos_bcm_dbg_run(data->initial_bcm_run, data); if (ret) { BCM_ERR("%s: failed to bcm initial run\n", __func__); goto err_initial_run; } } return 0; err_initial_run: #ifdef CONFIG_DEBUG_SNAPSHOT err_dump_config: #endif err_pd_sync_init: err_early_init: exynos_bcm_dbg_ipc_channel_release(data); err_ipc_channel: err_parse_dt: return ret; } #ifdef CONFIG_EXYNOS_BCM_DBG_GNR static enum hrtimer_restart bcm_monitor(struct hrtimer *hrtimer) { unsigned long flags; u32 period; enum hrtimer_restart ret = HRTIMER_NORESTART; spin_lock_irqsave(&bcm_dbg_data->lock, flags); period = bin_func->timer_event(); spin_unlock_irqrestore(&bcm_dbg_data->lock, flags); if (bcm_dbg_data->bcm_mode == BCM_MODE_ONCE || bcm_dbg_data->bcm_run_state == BCM_STOP) return ret; if (period > 0) { hrtimer_forward_now(hrtimer, ms_to_ktime(period)); ret = HRTIMER_RESTART; } return ret; } static void __iomem *bcm_ioremap(phys_addr_t phys_addr, size_t size) { void __iomem *ret; ret = ioremap(phys_addr, size); if (!ret) BCM_ERR("failed to map bcm physical address\n"); return ret; } int exynos_bcm_dbg_load_bin(void) { int ret = 0; char *lib_bcm = NULL; if (bcm_dbg_data->bcm_load_bin) return 0; os_func.print = printk; os_func.snprint = snprintf; os_func.ioremap = bcm_ioremap; os_func.iounmap = iounmap; os_func.sched_clock = sched_clock; lib_bcm = (char *)bcm_addr; bin_func = ((start_up_func_t)lib_bcm)((void **)&os_func); bcm_dbg_data->bcm_load_bin = true; hrtimer_init(&bcm_dbg_data->bcm_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); bcm_dbg_data->bcm_hrtimer.function = bcm_monitor; ret = exynos_bcm_dbg_init(bcm_dbg_data); if (ret) { BCM_ERR("%s: failed to bcm init\n", __func__); goto err_init; } err_init: return ret; } EXPORT_SYMBOL(exynos_bcm_dbg_load_bin); #endif static int exynos_bcm_dbg_pm_suspend(struct device *dev) { unsigned int suspend = true; int ret; #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (!bcm_dbg_data->bcm_load_bin) return 0; #endif BCM_DBG("%s: ++\n", __func__); ret = exynos_bcm_dbg_str(suspend, bcm_dbg_data); if (ret) { BCM_ERR("%s: failed set str state\n", __func__); return ret; } BCM_DBG("%s: --\n", __func__); return 0; } static int exynos_bcm_dbg_pm_resume(struct device *dev) { unsigned int suspend = false; int ret; #ifdef CONFIG_EXYNOS_BCM_DBG_GNR if (!bcm_dbg_data->bcm_load_bin) return 0; #endif BCM_DBG("%s: ++\n", __func__); ret = exynos_bcm_dbg_str(suspend, bcm_dbg_data); if (ret) { BCM_ERR("%s: failed set str state\n", __func__); return ret; } BCM_DBG("%s: --\n", __func__); return 0; } static struct dev_pm_ops exynos_bcm_dbg_pm_ops = { .suspend = exynos_bcm_dbg_pm_suspend, .resume = exynos_bcm_dbg_pm_resume, }; static int __init exynos_bcm_dbg_probe(struct platform_device *pdev) { int ret = 0; struct exynos_bcm_dbg_data *data; data = kzalloc(sizeof(struct exynos_bcm_dbg_data), GFP_KERNEL); if (data == NULL) { BCM_ERR("%s: failed to allocate BCM debug device\n", __func__); ret = -ENOMEM; goto err_data; } bcm_dbg_data = data; data->dev = &pdev->dev; spin_lock_init(&data->lock); #ifndef CONFIG_EXYNOS_BCM_DBG_GNR ret = exynos_bcm_dbg_init(data); if (ret) { BCM_ERR("%s: failed to bcm init\n", __func__); goto err_init; } #endif platform_set_drvdata(pdev, data); ret = sysfs_create_group(&data->dev->kobj, &exynos_bcm_dbg_attr_group); if (ret) BCM_ERR("%s: failed creat sysfs for Exynos BCM DBG\n", __func__); #ifdef CONFIG_EXYNOS_ITMON data->itmon_notifier.notifier_call = exynos_bcm_dbg_itmon_notifier; itmon_notifier_chain_register(&data->itmon_notifier); #endif BCM_INFO("%s: exynos bcm is initialized!!\n", __func__); return 0; #ifndef CONFIG_EXYNOS_BCM_DBG_GNR err_init: #endif kfree(data); data = NULL; err_data: return ret; } static int exynos_bcm_dbg_remove(struct platform_device *pdev) { struct exynos_bcm_dbg_data *data = platform_get_drvdata(pdev); int ret; sysfs_remove_group(&data->dev->kobj, &exynos_bcm_dbg_attr_group); platform_set_drvdata(pdev, NULL); ret = exynos_bcm_dbg_pd_sync_exit(data); if (ret) { BCM_ERR("%s: failed to pd_sync_exit\n", __func__); return ret; } exynos_bcm_dbg_ipc_channel_release(data); kfree(data); data = NULL; BCM_INFO("%s: exynos bcm is removed!!\n", __func__); return 0; } static int __init bcm_setup(char *str) { if (kstrtoul(str, 0, (unsigned long *)&bcm_addr)) goto out; return 0; out: return -EINVAL; } __setup("reserve-fimc=", bcm_setup); static struct platform_device_id exynos_bcm_dbg_driver_ids[] = { { .name = EXYNOS_BCM_DBG_MODULE_NAME, }, {}, }; MODULE_DEVICE_TABLE(platform, exynos_bcm_dbg_driver_ids); static const struct of_device_id exynos_bcm_dbg_match[] = { { .compatible = "samsung,exynos-bcm_dbg", }, {}, }; static struct platform_driver exynos_bcm_dbg_driver = { .remove = exynos_bcm_dbg_remove, .id_table = exynos_bcm_dbg_driver_ids, .driver = { .name = EXYNOS_BCM_DBG_MODULE_NAME, .owner = THIS_MODULE, .pm = &exynos_bcm_dbg_pm_ops, .of_match_table = exynos_bcm_dbg_match, }, }; module_platform_driver_probe(exynos_bcm_dbg_driver, exynos_bcm_dbg_probe); MODULE_AUTHOR("Taekki Kim "); MODULE_DESCRIPTION("Samsung BCM Debug driver"); MODULE_LICENSE("GPL");