antifallobst
/
lineage_kernel_xcoverpro
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
lineage_kernel_xcoverpro/drivers/soc/samsung/exynos-bcm_dbg.c

3360 lines
92 KiB
C
Executable File
Raw Permalink Blame History

/*
* 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 <linux/module.h>
#include <linux/kernel.h>
#include <linux/of_platform.h>
#include <linux/uaccess.h>
#include <linux/clk.h>
#include <linux/suspend.h>
#include <linux/memblock.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/of_reserved_mem.h>
#include <linux/debug-snapshot.h>
#include <linux/sched/clock.h>
#include <asm/map.h>
#include <asm/tlbflush.h>
#include <asm/cacheflush.h>
#ifdef CONFIG_EXYNOS_ADV_TRACER
#include <soc/samsung/exynos-adv-tracer-ipc.h>
#endif
#include <soc/samsung/exynos-bcm_dbg.h>
#include <soc/samsung/exynos-bcm_dbg-dt.h>
#include <soc/samsung/exynos-bcm_dbg-dump.h>
#include <soc/samsung/exynos-pd.h>
#include <soc/samsung/cal-if.h>
#ifdef CONFIG_EXYNOS_ITMON
#include <soc/samsung/exynos-itmon.h>
#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 <taekki.kim@samsung.com>");
MODULE_DESCRIPTION("Samsung BCM Debug driver");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink