evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

soc: qcom: glink: Add support for transport based logging

Browse source 
All Transports debug logs are captured in one logging context
which makes the debugging difficult and has a chance to miss
the important logs due to other high traffic transports like RPM.

Create separate logging context for each transports for better
debugging.

Change-Id: If2d00966a186dc48badc8a9a2e017eec6895dcad
Signed-off-by: Arun Kumar Neelakantam <aneela@codeaurora.org>
This commit is contained in:
Arun Kumar Neelakantam 2015-11-13 20:35:49 +05:30 • committed by David Keitel
parent 9e34c2bdf3
commit 9188869e03
3 changed files with 155 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
drivers/soc/qcom/glink.c
View file

@ -30,7 +30,7 @@
#include "glink_xprt_if.h"
/* Number of internal IPC Logging log pages */
#define NUM_LOG_PAGES 15
#define NUM_LOG_PAGES 10
#define GLINK_PM_QOS_HOLDOFF_MS 10
#define GLINK_QOS_DEF_NUM_TOKENS 10
#define GLINK_QOS_DEF_NUM_PRIORITY 1
@ -94,6 +94,7 @@ struct glink_qos_priority_bin {
* @tx_path_activity: transmit activity has occurred
* @pm_qos_work: removes PM QoS vote due to inactivity
* @xprt_dbgfs_lock_lhb3: debugfs channel structure lock
* @log_ctx: IPC logging context for this transport.
*/
struct glink_core_xprt_ctx {
struct rwref_lock xprt_state_lhb0;
@ -136,6 +137,7 @@ struct glink_core_xprt_ctx {
struct delayed_work pm_qos_work;
struct mutex xprt_dbgfs_lock_lhb3;
void *log_ctx;
};
/**
@ -3589,6 +3591,7 @@ int glink_core_register_transport(struct glink_transport_if *if_ptr,
size_t len;
uint16_t id;
int ret;
char log_name[GLINK_NAME_SIZE*2+2] = {0};
if (!if_ptr || !cfg || !cfg->name || !cfg->edge)
return -EINVAL;
@ -3676,6 +3679,12 @@ int glink_core_register_transport(struct glink_transport_if *if_ptr,
list_add_tail(&xprt_ptr->list_node, &transport_list);
mutex_unlock(&transport_list_lock_lha0);
glink_debugfs_add_xprt(xprt_ptr);
snprintf(log_name, sizeof(log_name), "%s_%s",
xprt_ptr->edge, xprt_ptr->name);
xprt_ptr->log_ctx = ipc_log_context_create(NUM_LOG_PAGES, log_name, 0);
if (!xprt_ptr->log_ctx)
GLINK_ERR("%s: unable to create log context for [%s:%s]\n",
__func__, xprt_ptr->edge, xprt_ptr->name);
return 0;
}
@ -3703,6 +3712,8 @@ void glink_core_unregister_transport(struct glink_transport_if *if_ptr)
mutex_unlock(&transport_list_lock_lha0);
flush_delayed_work(&xprt_ptr->pm_qos_work);
pm_qos_remove_request(&xprt_ptr->pm_qos_req);
ipc_log_context_destroy(xprt_ptr->log_ctx);
xprt_ptr->log_ctx = NULL;
rwref_put(&xprt_ptr->xprt_state_lhb0);
}
EXPORT_SYMBOL(glink_core_unregister_transport);
@ -3800,6 +3811,7 @@ static struct glink_core_xprt_ctx *glink_create_dummy_xprt_ctx(
if_ptr->tx_cmd_ch_remote_close_ack = dummy_tx_cmd_ch_remote_close_ack;
xprt_ptr->ops = if_ptr;
xprt_ptr->log_ctx = log_ctx;
spin_lock_init(&xprt_ptr->xprt_ctx_lock_lhb1);
INIT_LIST_HEAD(&xprt_ptr->free_lcid_list);
xprt_ptr->local_state = GLINK_XPRT_DOWN;
@ -5698,6 +5710,20 @@ void *glink_get_log_ctx(void)
}
EXPORT_SYMBOL(glink_get_log_ctx);
/**
* glink_get_xprt_log_ctx() - Return log context for GLINK xprts.
*
* Return: Log context or NULL if none.
*/
void *glink_get_xprt_log_ctx(struct glink_core_xprt_ctx *xprt)
{
if (xprt)
return xprt->log_ctx;
else
return NULL;
}
EXPORT_SYMBOL(glink_get_xprt_log_ctx);
static int glink_init(void)
{
log_ctx = ipc_log_context_create(NUM_LOG_PAGES, "glink", 0);

59
drivers/soc/qcom/glink_private.h
View file

@ -186,15 +186,36 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
GLINK_IPC_LOG_STR("<PERF> " x); \
} while (0)
#define GLINK_XPRT_IPC_LOG_STR(xprt, x...) do { \
if (glink_get_xprt_log_ctx(xprt)) \
ipc_log_string(glink_get_xprt_log_ctx(xprt), x); \
} while (0)
#define GLINK_XPRT_IF_INFO(xprt_if, x...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_INFO) \
GLINK_XPRT_IPC_LOG_STR(xprt_if.glink_core_priv, "<XPRT> " x); \
} while (0)
#define GLINK_XPRT_IF_DBG(xprt_if, x...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_DEBUG) \
GLINK_XPRT_IPC_LOG_STR(xprt_if.glink_core_priv, "<XPRT> " x); \
} while (0)
#define GLINK_XPRT_IF_ERR(xprt_if, x...) do { \
pr_err("<XPRT> " x); \
GLINK_XPRT_IPC_LOG_STR(xprt_if.glink_core_priv, "<XPRT> " x); \
} while (0)
#define GLINK_PERF_XPRT(xprt, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_PERF) \
GLINK_IPC_LOG_STR("<PERF> %s:%s " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt, "<PERF> %s:%s " fmt, \
xprt->name, xprt->edge, args); \
} while (0)
#define GLINK_PERF_CH(ctx, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_PERF) \
GLINK_IPC_LOG_STR("<PERF> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(ctx->transport_ptr, \
"<PERF> %s:%s:%s[%u:%u] " fmt, \
ctx->transport_ptr->name, \
ctx->transport_ptr->edge, \
ctx->name, \
@ -204,7 +225,8 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
#define GLINK_PERF_CH_XPRT(ctx, xprt, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_PERF) \
GLINK_IPC_LOG_STR("<PERF> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt, \
"<PERF> %s:%s:%s[%u:%u] " fmt, \
xprt->name, \
xprt->edge, \
ctx->name, \
@ -214,13 +236,14 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
#define GLINK_INFO_PERF_XPRT(xprt, fmt, args...) do { \
if (glink_get_debug_mask() & (QCOM_GLINK_INFO | QCOM_GLINK_PERF)) \
GLINK_IPC_LOG_STR("<CORE> %s:%s " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt, "<CORE> %s:%s " fmt, \
xprt->name, xprt->edge, args); \
} while (0)
#define GLINK_INFO_PERF_CH(ctx, fmt, args...) do { \
if (glink_get_debug_mask() & (QCOM_GLINK_INFO | QCOM_GLINK_PERF)) \
GLINK_IPC_LOG_STR("<CORE> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(ctx->transport_ptr, \
"<CORE> %s:%s:%s[%u:%u] " fmt, \
ctx->transport_ptr->name, \
ctx->transport_ptr->edge, \
ctx->name, \
@ -230,7 +253,8 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
#define GLINK_INFO_PERF_CH_XPRT(ctx, xprt, fmt, args...) do { \
if (glink_get_debug_mask() & (QCOM_GLINK_INFO | QCOM_GLINK_PERF)) \
GLINK_IPC_LOG_STR("<CORE> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt,\
"<CORE> %s:%s:%s[%u:%u] " fmt, \
xprt->name, \
xprt->edge, \
ctx->name, \
@ -240,13 +264,14 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
#define GLINK_INFO_XPRT(xprt, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_INFO) \
GLINK_IPC_LOG_STR("<CORE> %s:%s " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt, "<CORE> %s:%s " fmt, \
xprt->name, xprt->edge, args); \
} while (0)
#define GLINK_INFO_CH(ctx, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_INFO) \
GLINK_IPC_LOG_STR("<CORE> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(ctx->transport_ptr, \
"<CORE> %s:%s:%s[%u:%u] " fmt, \
ctx->transport_ptr->name, \
ctx->transport_ptr->edge, \
ctx->name, \
@ -256,7 +281,8 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
#define GLINK_INFO_CH_XPRT(ctx, xprt, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_INFO) \
GLINK_IPC_LOG_STR("<CORE> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt, \
"<CORE> %s:%s:%s[%u:%u] " fmt, \
xprt->name, \
xprt->edge, \
ctx->name, \
@ -266,13 +292,14 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
#define GLINK_DBG_XPRT(xprt, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_DEBUG) \
GLINK_IPC_LOG_STR("<CORE> %s:%s " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt, "<CORE> %s:%s " fmt, \
xprt->name, xprt->edge, args); \
} while (0)
#define GLINK_DBG_CH(ctx, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_DEBUG) \
GLINK_IPC_LOG_STR("<CORE> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(ctx->transport_ptr, \
"<CORE> %s:%s:%s[%u:%u] " fmt, \
ctx->transport_ptr->name, \
ctx->transport_ptr->edge, \
ctx->name, \
@ -282,7 +309,8 @@ const char *glink_get_ch_state_string(enum local_channel_state_e enum_id);
#define GLINK_DBG_CH_XPRT(ctx, xprt, fmt, args...) do { \
if (glink_get_debug_mask() & QCOM_GLINK_DEBUG) \
GLINK_IPC_LOG_STR("<CORE> %s:%s:%s[%u:%u] " fmt, \
GLINK_XPRT_IPC_LOG_STR(xprt, \
"<CORE> %s:%s:%s[%u:%u] " fmt, \
xprt->name, \
xprt->edge, \
ctx->name, \
@ -346,6 +374,13 @@ unsigned glink_get_debug_mask(void);
*/
void *glink_get_log_ctx(void);
/**
* glink_get_xprt_log_ctx() - Return log context for other GLINK modules.
*
* Return: Log context or NULL if none.
*/
void *glink_get_xprt_log_ctx(struct glink_core_xprt_ctx *xprt);
/**
* glink_get_channel_id_for_handle() - Get logical channel ID
*

142
drivers/soc/qcom/glink_smd_xprt.c
View file

@ -54,9 +54,9 @@ enum command_types {
*/
#define LEGACY_RCID_CHANNEL_OFFSET 128
#define SMDXPRT_ERR(x...) GLINK_ERR("<SMDXPRT> " x)
#define SMDXPRT_INFO(x...) GLINK_INFO("<SMDXPRT> " x)
#define SMDXPRT_DBG(x...) GLINK_DBG("<SMDXPRT> " x)
#define SMDXPRT_ERR(einfo, x...) GLINK_XPRT_IF_ERR(einfo->xprt_if, x)
#define SMDXPRT_INFO(einfo, x...) GLINK_XPRT_IF_INFO(einfo->xprt_if, x)
#define SMDXPRT_DBG(einfo, x...) GLINK_XPRT_IF_DBG(einfo->xprt_if, x)
/**
* struct edge_info() - local information for managing an edge
@ -295,7 +295,8 @@ static void process_ctl_event(struct work_struct *work)
smd_read(einfo->smd_ch, &cmd, sizeof(cmd));
if (cmd.cmd == CMD_OPEN) {
smd_read(einfo->smd_ch, name, GLINK_NAME_SIZE);
SMDXPRT_INFO("%s RX OPEN '%s'\n", __func__, name);
SMDXPRT_INFO(einfo, "%s RX OPEN '%s'\n",
__func__, name);
spin_lock_irqsave(&einfo->channels_lock, flags);
list_for_each_entry(ch, &einfo->channels, node) {
@ -309,8 +310,9 @@ static void process_ctl_event(struct work_struct *work)
if (!found) {
ch = kzalloc(sizeof(*ch), GFP_KERNEL);
if (!ch) {
SMDXPRT_ERR("%s: ch alloc failed\n",
__func__);
SMDXPRT_ERR(einfo,
"%s: ch alloc failed\n",
__func__);
continue;
}
strlcpy(ch->name, name, GLINK_NAME_SIZE);
@ -323,8 +325,9 @@ static void process_ctl_event(struct work_struct *work)
ch->wq = create_singlethread_workqueue(
ch->name);
if (!ch->wq) {
SMDXPRT_ERR("%s: ch wq create failed\n",
__func__);
SMDXPRT_ERR(einfo,
"%s: ch wq create failed\n",
__func__);
kfree(ch);
continue;
}
@ -358,7 +361,7 @@ static void process_ctl_event(struct work_struct *work)
}
if (ch->remote_legacy) {
SMDXPRT_DBG("%s SMD Remote Open '%s'\n",
SMDXPRT_DBG(einfo, "%s SMD Remote Open '%s'\n",
__func__, name);
cmd.cmd = CMD_OPEN_ACK;
cmd.priority = SMD_TRANS_XPRT_ID;
@ -370,7 +373,8 @@ static void process_ctl_event(struct work_struct *work)
mutex_unlock(&einfo->smd_lock);
continue;
} else {
SMDXPRT_DBG("%s G-Link Remote Open '%s'\n",
SMDXPRT_DBG(einfo,
"%s G-Link Remote Open '%s'\n",
__func__, name);
}
@ -381,7 +385,8 @@ static void process_ctl_event(struct work_struct *work)
name,
cmd.priority);
} else if (cmd.cmd == CMD_OPEN_ACK) {
SMDXPRT_INFO("%s RX OPEN ACK lcid %u; xprt_req %u\n",
SMDXPRT_INFO(einfo,
"%s RX OPEN ACK lcid %u; xprt_req %u\n",
__func__, cmd.id, cmd.priority);
spin_lock_irqsave(&einfo->channels_lock, flags);
@ -392,7 +397,7 @@ static void process_ctl_event(struct work_struct *work)
}
spin_unlock_irqrestore(&einfo->channels_lock, flags);
if (!found) {
GLINK_ERR("%s <SMDXPRT> No channel match %u\n",
SMDXPRT_ERR(einfo, "%s No channel match %u\n",
__func__, cmd.id);
continue;
}
@ -403,8 +408,8 @@ static void process_ctl_event(struct work_struct *work)
cmd.id,
cmd.priority);
} else if (cmd.cmd == CMD_CLOSE) {
SMDXPRT_INFO("%s RX REMOTE CLOSE rcid %u\n", __func__,
cmd.id);
SMDXPRT_INFO(einfo, "%s RX REMOTE CLOSE rcid %u\n",
__func__, cmd.id);
spin_lock_irqsave(&einfo->channels_lock, flags);
list_for_each_entry(ch, &einfo->channels, node)
if (cmd.id == ch->rcid) {
@ -414,7 +419,7 @@ static void process_ctl_event(struct work_struct *work)
spin_unlock_irqrestore(&einfo->channels_lock, flags);
if (!found)
GLINK_ERR("%s <SMDXPRT> no matching rcid %u\n",
SMDXPRT_ERR(einfo, "%s no matching rcid %u\n",
__func__, cmd.id);
if (found && !ch->remote_legacy) {
@ -424,7 +429,8 @@ static void process_ctl_event(struct work_struct *work)
cmd.id);
} else {
/* not found or a legacy channel */
SMDXPRT_INFO("%s Sim RX CLOSE ACK lcid %u\n",
SMDXPRT_INFO(einfo,
"%s Sim RX CLOSE ACK lcid %u\n",
__func__, cmd.id);
cmd.cmd = CMD_CLOSE_ACK;
mutex_lock(&einfo->smd_lock);
@ -437,8 +443,8 @@ static void process_ctl_event(struct work_struct *work)
} else if (cmd.cmd == CMD_CLOSE_ACK) {
int rcu_id;
SMDXPRT_INFO("%s RX CLOSE ACK lcid %u\n", __func__,
cmd.id);
SMDXPRT_INFO(einfo, "%s RX CLOSE ACK lcid %u\n",
__func__, cmd.id);
spin_lock_irqsave(&einfo->channels_lock, flags);
list_for_each_entry(ch, &einfo->channels, node) {
@ -449,7 +455,7 @@ static void process_ctl_event(struct work_struct *work)
}
spin_unlock_irqrestore(&einfo->channels_lock, flags);
if (!found) {
GLINK_ERR("%s <SMDXPRT> LCID not found %u\n",
SMDXPRT_ERR(einfo, "%s LCID not found %u\n",
__func__, cmd.id);
continue;
}
@ -500,8 +506,9 @@ static int ctl_ch_probe(struct platform_device *pdev)
ret = smd_named_open_on_edge("GLINK_CTRL", einfo->smd_edge,
&einfo->smd_ch, einfo, ctl_ch_notify);
if (ret != 0)
SMDXPRT_ERR("%s Opening failed %d for %d:'GLINK_CTRL'\n",
__func__, ret, einfo->smd_edge);
SMDXPRT_ERR(einfo,
"%s Opening failed %d for %d:'GLINK_CTRL'\n",
__func__, ret, einfo->smd_edge);
return ret;
}
@ -692,7 +699,7 @@ static void process_data_event(struct work_struct *work)
pkt_remaining = smd_cur_packet_size(ch->smd_ch);
else
pkt_remaining = smd_read_avail(ch->smd_ch);
GLINK_DBG("%s <SMDXPRT> Reading packet chunk %u '%s' %u:%u\n",
SMDXPRT_DBG(einfo, "%s Reading packet chunk %u '%s' %u:%u\n",
__func__, pkt_remaining, ch->name, ch->lcid,
ch->rcid);
if (!ch->cur_intent && !einfo->intentless) {
@ -709,9 +716,10 @@ static void process_data_event(struct work_struct *work)
if (!ch->cur_intent) {
spin_unlock_irqrestore(&ch->rx_data_lock,
rx_data_flags);
GLINK_DBG("%s %s Reqesting intent '%s' %u:%u\n",
__func__, "<SMDXPRT>", ch->name,
ch->lcid, ch->rcid);
SMDXPRT_DBG(einfo,
"%s Reqesting intent '%s' %u:%u\n",
__func__, ch->name,
ch->lcid, ch->rcid);
ch->intent_req = true;
einfo->xprt_if.glink_core_if_ptr->
rx_cmd_remote_rx_intent_req(
@ -733,8 +741,9 @@ static void process_data_event(struct work_struct *work)
if (!intent->data && einfo->intentless) {
intent->data = kmalloc(pkt_remaining, GFP_ATOMIC);
if (!intent->data) {
GLINK_DBG("%s %s kmalloc failed '%s' %u:%u\n",
__func__, "<SMDXPRT>", ch->name,
SMDXPRT_DBG(einfo,
"%s kmalloc failed '%s' %u:%u\n",
__func__, ch->name,
ch->lcid, ch->rcid);
continue;
}
@ -778,7 +787,8 @@ static void smd_data_ch_notify(void *priv, unsigned event)
case SMD_EVENT_OPEN:
work = kmalloc(sizeof(*work), GFP_ATOMIC);
if (!work) {
SMDXPRT_ERR("%s: unable to process event %d\n",
SMDXPRT_ERR(ch->edge,
"%s: unable to process event %d\n",
__func__, SMD_EVENT_OPEN);
return;
}
@ -789,7 +799,8 @@ static void smd_data_ch_notify(void *priv, unsigned event)
case SMD_EVENT_CLOSE:
work = kmalloc(sizeof(*work), GFP_ATOMIC);
if (!work) {
SMDXPRT_ERR("%s: unable to process event %d\n",
SMDXPRT_ERR(ch->edge,
"%s: unable to process event %d\n",
__func__, SMD_EVENT_CLOSE);
return;
}
@ -798,12 +809,14 @@ static void smd_data_ch_notify(void *priv, unsigned event)
queue_work(ch->wq, &work->work);
break;
case SMD_EVENT_STATUS:
SMDXPRT_DBG("%s Processing STATUS for '%s' %u:%u\n", __func__,
ch->name, ch->lcid, ch->rcid);
SMDXPRT_DBG(ch->edge,
"%s Processing STATUS for '%s' %u:%u\n",
__func__, ch->name, ch->lcid, ch->rcid);
work = kmalloc(sizeof(*work), GFP_ATOMIC);
if (!work) {
SMDXPRT_ERR("%s: unable to process event %d\n",
SMDXPRT_ERR(ch->edge,
"%s: unable to process event %d\n",
__func__, SMD_EVENT_STATUS);
return;
}
@ -814,7 +827,8 @@ static void smd_data_ch_notify(void *priv, unsigned event)
case SMD_EVENT_REOPEN_READY:
work = kmalloc(sizeof(*work), GFP_ATOMIC);
if (!work) {
SMDXPRT_ERR("%s: unable to process event %d\n",
SMDXPRT_ERR(ch->edge,
"%s: unable to process event %d\n",
__func__, SMD_EVENT_REOPEN_READY);
return;
}
@ -836,7 +850,8 @@ static void smd_data_ch_close(struct channel *ch)
struct intent_info *intent;
unsigned long flags;
SMDXPRT_INFO("%s Closing SMD channel lcid %u\n", __func__, ch->lcid);
SMDXPRT_INFO(ch->edge, "%s Closing SMD channel lcid %u\n",
__func__, ch->lcid);
ch->is_closing = true;
ch->wait_for_probe = false;
@ -877,13 +892,13 @@ static void data_ch_probe_body(struct channel *ch)
int ret;
einfo = ch->edge;
SMDXPRT_DBG("%s Opening SMD channel %d:'%s'\n", __func__,
SMDXPRT_DBG(einfo, "%s Opening SMD channel %d:'%s'\n", __func__,
einfo->smd_edge, ch->name);
ret = smd_named_open_on_edge(ch->name, einfo->smd_edge, &ch->smd_ch, ch,
smd_data_ch_notify);
if (ret != 0) {
SMDXPRT_ERR("%s Opening failed %d for %d:'%s'\n",
SMDXPRT_ERR(einfo, "%s Opening failed %d for %d:'%s'\n",
__func__, ret, einfo->smd_edge, ch->name);
return;
}
@ -1120,8 +1135,9 @@ static int tx_cmd_ch_open(struct glink_transport_if *if_ptr, uint32_t lcid,
if (!found) {
ch = kzalloc(sizeof(*ch), GFP_KERNEL);
if (!ch) {
SMDXPRT_ERR("%s: channel struct allocation failed\n",
__func__);
SMDXPRT_ERR(einfo,
"%s: channel struct allocation failed\n",
__func__);
srcu_read_unlock(&einfo->ssr_sync, rcu_id);
return -ENOMEM;
}
@ -1134,8 +1150,9 @@ static int tx_cmd_ch_open(struct glink_transport_if *if_ptr, uint32_t lcid,
INIT_WORK(&ch->work, process_data_event);
ch->wq = create_singlethread_workqueue(ch->name);
if (!ch->wq) {
SMDXPRT_ERR("%s: channel workqueue create failed\n",
__func__);
SMDXPRT_ERR(einfo,
"%s: channel workqueue create failed\n",
__func__);
kfree(ch);
srcu_read_unlock(&einfo->ssr_sync, rcu_id);
return -ENOMEM;
@ -1169,8 +1186,8 @@ static int tx_cmd_ch_open(struct glink_transport_if *if_ptr, uint32_t lcid,
ch->lcid = lcid;
if (einfo->smd_ctl_ch_open) {
SMDXPRT_INFO("%s TX OPEN '%s' lcid %u reqxprt %u\n", __func__,
name, lcid, req_xprt);
SMDXPRT_INFO(einfo, "%s TX OPEN '%s' lcid %u reqxprt %u\n",
__func__, name, lcid, req_xprt);
cmd.cmd = CMD_OPEN;
cmd.id = lcid;
cmd.priority = req_xprt;
@ -1185,7 +1202,7 @@ static int tx_cmd_ch_open(struct glink_transport_if *if_ptr, uint32_t lcid,
smd_write_end(einfo->smd_ch);
mutex_unlock(&einfo->smd_lock);
} else {
SMDXPRT_INFO("%s Legacy Open '%s' lcid %u reqxprt %u\n",
SMDXPRT_INFO(einfo, "%s Legacy Open '%s' lcid %u reqxprt %u\n",
__func__, name, lcid, req_xprt);
ch->rcid = lcid + LEGACY_RCID_CHANNEL_OFFSET;
ch->local_legacy = true;
@ -1239,13 +1256,14 @@ static int tx_cmd_ch_close(struct glink_transport_if *if_ptr, uint32_t lcid)
spin_unlock_irqrestore(&einfo->channels_lock, flags);
if (!found) {
GLINK_ERR("%s <SMDXPRT> LCID not found %u\n", __func__, lcid);
SMDXPRT_ERR(einfo, "%s LCID not found %u\n",
__func__, lcid);
srcu_read_unlock(&einfo->ssr_sync, rcu_id);
return -ENODEV;
}
if (!ch->local_legacy) {
SMDXPRT_INFO("%s TX CLOSE lcid %u\n", __func__, lcid);
SMDXPRT_INFO(einfo, "%s TX CLOSE lcid %u\n", __func__, lcid);
cmd.cmd = CMD_CLOSE;
cmd.id = lcid;
cmd.reserved = 0;
@ -1296,19 +1314,19 @@ static void tx_cmd_ch_remote_open_ack(struct glink_transport_if *if_ptr,
spin_unlock_irqrestore(&einfo->channels_lock, flags);
if (!found) {
GLINK_ERR("%s <SMDXPRT> No matching SMD channel for rcid %u\n",
SMDXPRT_ERR(einfo, "%s No matching SMD channel for rcid %u\n",
__func__, rcid);
return;
}
if (ch->remote_legacy) {
SMDXPRT_INFO("%s Legacy ch rcid %u xprt_resp %u\n", __func__,
rcid, xprt_resp);
SMDXPRT_INFO(einfo, "%s Legacy ch rcid %u xprt_resp %u\n",
__func__, rcid, xprt_resp);
return;
}
SMDXPRT_INFO("%s TX OPEN ACK rcid %u xprt_resp %u\n", __func__, rcid,
xprt_resp);
SMDXPRT_INFO(einfo, "%s TX OPEN ACK rcid %u xprt_resp %u\n",
__func__, rcid, xprt_resp);
cmd.cmd = CMD_OPEN_ACK;
cmd.id = ch->rcid;
@ -1353,13 +1371,15 @@ static void tx_cmd_ch_remote_close_ack(struct glink_transport_if *if_ptr,
spin_unlock_irqrestore(&einfo->channels_lock, flags);
if (!found) {
GLINK_ERR("%s <SMDXPRT> No matching SMD channel for rcid %u\n",
__func__, rcid);
SMDXPRT_ERR(einfo,
"%s No matching SMD channel for rcid %u\n",
__func__, rcid);
return;
}
if (!ch->remote_legacy) {
SMDXPRT_INFO("%s TX CLOSE ACK rcid %u\n", __func__, rcid);
SMDXPRT_INFO(einfo, "%s TX CLOSE ACK rcid %u\n",
__func__, rcid);
cmd.cmd = CMD_CLOSE_ACK;
cmd.id = rcid;
cmd.reserved = 0;
@ -1522,7 +1542,7 @@ static int tx_cmd_local_rx_intent(struct glink_transport_if *if_ptr,
intent = kmalloc(sizeof(*intent), GFP_KERNEL);
if (!intent) {
SMDXPRT_ERR("%s: no memory for intent\n", __func__);
SMDXPRT_ERR(einfo, "%s: no memory for intent\n", __func__);
srcu_read_unlock(&einfo->ssr_sync, rcu_id);
return -ENOMEM;
}
@ -1643,8 +1663,8 @@ static int tx(struct glink_transport_if *if_ptr, uint32_t lcid,
rc = tx_size;
rc = smd_write_segment(ch->smd_ch, data_start, rc);
if (rc < 0) {
SMDXPRT_ERR("%s: write segment failed %d\n", __func__,
rc);
SMDXPRT_ERR(einfo, "%s: write segment failed %d\n",
__func__, rc);
srcu_read_unlock(&einfo->ssr_sync, rcu_id);
return rc;
}
@ -1658,7 +1678,8 @@ static int tx(struct glink_transport_if *if_ptr, uint32_t lcid,
rc = tx_size;
rc = smd_write(ch->smd_ch, data_start, rc);
if (rc < 0) {
SMDXPRT_ERR("%s: write failed %d\n", __func__, rc);
SMDXPRT_ERR(einfo, "%s: write failed %d\n",
__func__, rc);
srcu_read_unlock(&einfo->ssr_sync, rcu_id);
return rc;
}
@ -1923,10 +1944,9 @@ static int __init glink_smd_xprt_init(void)
rc = glink_core_register_transport(&einfo->xprt_if,
&einfo->xprt_cfg);
if (rc)
SMDXPRT_ERR("%s: %s glink register xprt failed %d\n",
__func__,
einfo->xprt_cfg.edge,
rc);
SMDXPRT_ERR(einfo,
"%s: %s glink register xprt failed %d\n",
__func__, einfo->xprt_cfg.edge, rc);
else
einfo->xprt_if.glink_core_if_ptr->link_up(
&einfo->xprt_if);