From da85175a9fbe3573b4d0be1f0b0e10cae62781c6 Mon Sep 17 00:00:00 2001 From: Jyothi Kumar Seerapu Date: Tue, 22 Mar 2022 11:50:21 +0530 Subject: [PATCH] msm: mhi_dev: Change MHI logs for Channel and Ring Ids Currently the MHI logs are not unique for channel and ring ids. Post this change, all channel ids can be found with ch_id:xx and all ring ids can be found with ring_id:yy in MHI logs, thus making the debugging process easier. Change-Id: I6352911814795792f796b2062da6465da7af89ff Signed-off-by: Jyothi Kumar Seerapu --- drivers/platform/msm/mhi_dev/mhi.c | 183 +++++++++++---------- drivers/platform/msm/mhi_dev/mhi_dev_net.c | 27 +-- drivers/platform/msm/mhi_dev/mhi_mmio.c | 2 +- drivers/platform/msm/mhi_dev/mhi_ring.c | 35 ++-- drivers/platform/msm/mhi_dev/mhi_uci.c | 103 ++++++------ 5 files changed, 185 insertions(+), 165 deletions(-) diff --git a/drivers/platform/msm/mhi_dev/mhi.c b/drivers/platform/msm/mhi_dev/mhi.c index 89cb1a703035..1b6259bdcaba 100644 --- a/drivers/platform/msm/mhi_dev/mhi.c +++ b/drivers/platform/msm/mhi_dev/mhi.c @@ -300,14 +300,16 @@ static int mhi_dev_schedule_msi_ipa(struct mhi_dev *mhi, struct event_req *ereq) ereq->msi_cb = mhi_dev_event_msi_cb; ch->msi_cnt++; mhi_log(MHI_MSG_VERBOSE, - "Sending MSI %d to 0x%llx as data = 0x%x for ch %d msi_count %d, ereq flush_num %d\n", + "Sending MSI %d to 0x%llx as data = 0x%x for ch_id:%d\t" + "msi_count %d, ereq flush_num %d\n", ctx->ev.msivec, msi_addr.host_pa, *ring->msi_buf, ch->ch_id, ch->msi_cnt, ereq->flush_num); } else { ereq->msi_cb = mhi_dev_cmd_event_msi_cb; mhi_log(MHI_MSG_VERBOSE, - "Sending MSI %d to 0x%llx as data = 0x%x for cmd ack, ereq flush_num %d\n", + "Sending MSI %d to 0x%llx as data = 0x%x for cmd ack\t" + "ereq flush_num %d\n", ctx->ev.msivec, msi_addr.host_pa, *ring->msi_buf, ereq->flush_num); } @@ -471,12 +473,12 @@ static int mhi_dev_send_multiple_tr_events(struct mhi_dev *mhi, int evnt_ring, if (evnt_ring_idx > mhi->cfg.event_rings) { mhi_log(MHI_MSG_ERROR, - "Invalid event ring idx: %lld\n", evnt_ring_idx); + "Invalid event ring_id:%lld\n", evnt_ring_idx); return -EINVAL; } if (!ring) { - mhi_log(MHI_MSG_ERROR, "Ring %d not present\n", + mhi_log(MHI_MSG_ERROR, "ring_id:%d not present\n", evnt_ring_idx); return -EINVAL; } @@ -487,7 +489,8 @@ static int mhi_dev_send_multiple_tr_events(struct mhi_dev *mhi, int evnt_ring, rc = mhi_ring_start(ring, ctx, mhi); if (rc) { mhi_log(MHI_MSG_ERROR, - "error starting event ring %d\n", evnt_ring); + "error starting event ring_id:%d\n", + evnt_ring_idx); return rc; } } @@ -513,12 +516,12 @@ static int mhi_dev_send_multiple_tr_events(struct mhi_dev *mhi, int evnt_ring, if (ch->state == MHI_DEV_CH_STOPPED || ch->state == MHI_DEV_CH_PENDING_STOP) { mhi_log(MHI_MSG_ERROR, - "Ch:%d is in %d state, abort sending completion evnt\n" + "ch_id:%d is in %d state, abort sending cmpl evnt\n" , ch->ch_id, ch->state); rc = -ENXIO; goto exit; } - mhi_log(MHI_MSG_VERBOSE, "Flushing %d cmpl events of ch %d\n", + mhi_log(MHI_MSG_VERBOSE, "Flushing %d cmpl events of ch_id:%d\n", ereq->num_events, ch->ch_id); } else { mhi_log(MHI_MSG_VERBOSE, @@ -651,7 +654,7 @@ static int mhi_dev_flush_transfer_completion_events(struct mhi_dev *mhi, if (ch->state == MHI_DEV_CH_CLOSED || ch->state == MHI_DEV_CH_STOPPED) { mhi_log(MHI_MSG_DBG, - "Ch %d closed with %d writes pending\n", + "ch_id:%d closed with %d writes pending\n", ch->ch_id, ch->pend_wr_count + 1); rc = -ENODEV; break; @@ -667,7 +670,7 @@ static int mhi_dev_flush_transfer_completion_events(struct mhi_dev *mhi, if (ch->flush_req_cnt++ >= U32_MAX) ch->flush_req_cnt = 0; flush_ereq->flush_num = ch->flush_req_cnt; - mhi_log(MHI_MSG_DBG, "Flush num %d called for ch %d\n", + mhi_log(MHI_MSG_DBG, "Flush num %d called for ch_id:%d\n", ch->flush_req_cnt, ch->ch_id); /* Check the limits of the buffer to be flushed */ @@ -852,12 +855,14 @@ int mhi_transfer_host_to_device_ipa(void *dev, uint64_t host_pa, uint32_t len, mhi_log(MHI_MSG_VERBOSE, "device 0x%llx <-- host 0x%llx, size %d\n", (uint64_t) mhi->read_dma_handle, host_addr_pa, (int) len); + ch = mreq->client->channel; if (mreq->mode == DMA_SYNC) { rc = ipa_dma_sync_memcpy((u64) mhi->read_dma_handle, host_addr_pa, (int) len); if (rc) { mhi_log(MHI_MSG_ERROR, - "error while reading chan using sync:%d\n", rc); + "error while reading ch_id:%d using sync, rc\n", + ch->ch_id, rc); return rc; } memcpy(dev, mhi->read_handle, len); @@ -870,7 +875,8 @@ int mhi_transfer_host_to_device_ipa(void *dev, uint64_t host_pa, uint32_t len, if (ring->rd_offset == ring->wr_offset) { mhi_log(MHI_MSG_VERBOSE, - "Setting snd_cmpl to 1 for ch %d\n", ch->ch_id); + "Setting snd_cmpl to 1 for ch_id:%d\n", + ch->ch_id); mreq->snd_cmpl = 1; } @@ -878,7 +884,7 @@ int mhi_transfer_host_to_device_ipa(void *dev, uint64_t host_pa, uint32_t len, rc = mhi_dev_queue_transfer_completion(mreq, NULL); if (rc) { mhi_log(MHI_MSG_ERROR, - "Failed to queue completion for ch %d, rc %d\n", + "Failed to queue completion for ch_id:%d, rc %d\n", ch->ch_id, rc); return rc; } @@ -888,7 +894,8 @@ int mhi_transfer_host_to_device_ipa(void *dev, uint64_t host_pa, uint32_t len, mreq); if (rc) { mhi_log(MHI_MSG_ERROR, - "DMA read error %d for ch %d\n", rc, ch->ch_id); + "DMA read error %d for ch_id:%d\n", + rc, ch->ch_id); /* Roll back the completion event that we wrote above */ mhi_dev_rollback_compl_evt(ch); /* Unmap the buffer */ @@ -1187,7 +1194,8 @@ int mhi_transfer_host_to_device_edma(void *dev, uint64_t host_pa, uint32_t len, if (ring->rd_offset == ring->wr_offset) { mhi_log(MHI_MSG_VERBOSE, - "Setting snd_cmpl to 1 for ch %d\n", ch->ch_id); + "Setting snd_cmpl to 1 for ch_id:%d\n", + ch->ch_id); mreq->snd_cmpl = 1; } @@ -1489,7 +1497,7 @@ static void mhi_hwc_cb(void *priv, enum ipa_mhi_event_type event, switch (event) { case IPA_MHI_EVENT_READY: mhi_log(MHI_MSG_INFO, - "HW Channel uC is ready event=0x%X\n", event); + "HW ch uC is ready event=0x%X\n", event); rc = mhi_hwc_start(mhi_ctx); if (rc) { mhi_log(MHI_MSG_ERROR, @@ -1516,7 +1524,7 @@ static void mhi_hwc_cb(void *priv, enum ipa_mhi_event_type event, break; default: mhi_log(MHI_MSG_ERROR, - "HW Channel uC unknown event 0x%X\n", event); + "HW ch uC unknown event 0x%X\n", event); break; } } @@ -1534,7 +1542,7 @@ static int mhi_hwc_chcmd(struct mhi_dev *mhi, uint chid, case MHI_DEV_RING_EL_STOP: if ((chid-HW_CHANNEL_BASE) > NUM_HW_CHANNELS) { mhi_log(MHI_MSG_ERROR, - "Invalid Channel ID = 0x%X\n", chid); + "Invalid HW ch_id:%d\n", chid); return -EINVAL; } @@ -1542,7 +1550,7 @@ static int mhi_hwc_chcmd(struct mhi_dev *mhi, uint chid, mhi->ipa_clnt_hndl[chid-HW_CHANNEL_BASE]); if (rc) mhi_log(MHI_MSG_ERROR, - "Stopping HW Channel%d failed 0x%X\n", + "Stopping HW ch_id:%d failed 0x%X\n", chid, rc); break; case MHI_DEV_RING_EL_START: @@ -1551,13 +1559,13 @@ static int mhi_hwc_chcmd(struct mhi_dev *mhi, uint chid, if (chid > HW_CHANNEL_END) { mhi_log(MHI_MSG_ERROR, - "Channel DB for %d not enabled\n", chid); + "ch DB for ch_id:%d not enabled\n", chid); return -EINVAL; } if ((chid-HW_CHANNEL_BASE) > NUM_HW_CHANNELS) { mhi_log(MHI_MSG_ERROR, - "Invalid Channel = 0x%X\n", chid); + "Invalid HW ch_id:%d\n", chid); return -EINVAL; } @@ -1565,7 +1573,7 @@ static int mhi_hwc_chcmd(struct mhi_dev *mhi, uint chid, &mhi->ipa_clnt_hndl[chid-HW_CHANNEL_BASE]); if (rc) mhi_log(MHI_MSG_ERROR, - "HW Channel%d start failed : %d\n", + "HW ch_id:%d start failed : %d\n", chid, rc); break; case MHI_DEV_RING_EL_INVALID: @@ -1641,7 +1649,7 @@ int mhi_dev_send_event(struct mhi_dev *mhi, int evnt_ring, if (evnt_ring_idx > mhi->cfg.event_rings) { mhi_log(MHI_MSG_ERROR, - "Invalid event ring idx: %lld\n", evnt_ring_idx); + "Invalid event ring_id: %lld\n", evnt_ring_idx); return -EINVAL; } @@ -1650,7 +1658,8 @@ int mhi_dev_send_event(struct mhi_dev *mhi, int evnt_ring, rc = mhi_ring_start(ring, ctx, mhi); if (rc) { mhi_log(MHI_MSG_ERROR, - "error starting event ring %d\n", evnt_ring); + "error starting event ring_id:%d\n", + evnt_ring_idx); return rc; } } @@ -1719,12 +1728,12 @@ static int mhi_dev_send_completion_event_async(struct mhi_dev_channel *ch, rc = mhi_dev_queue_transfer_completion(mreq, NULL); if (rc) { mhi_log(MHI_MSG_ERROR, - "Failed to queue completion for ch %d, rc %d\n", + "Failed to queue completion for ch_id:%d, rc %d\n", ch->ch_id, rc); return rc; } - mhi_log(MHI_MSG_VERBOSE, "Calling flush for ch %d\n", ch->ch_id); + mhi_log(MHI_MSG_VERBOSE, "Calling flush for ch_id:%d\n", ch->ch_id); rc = mhi_dev_flush_transfer_completion_events(mhi, ch); if (rc) { mhi_log(MHI_MSG_ERROR, @@ -1878,7 +1887,7 @@ static void mhi_dev_process_reset_cmd(struct mhi_dev *mhi, int ch_id) rc = mhi_dev_mmio_disable_chdb_a7(mhi, ch_id); if (rc) { mhi_log(MHI_MSG_VERBOSE, - "Failed to disable chdb for ch %d\n", ch_id); + "Failed to disable chdb for ch_id:%d\n", ch_id); rc = mhi_dev_send_cmd_comp_event(mhi, MHI_CMD_COMPL_CODE_UNDEFINED); if (rc) @@ -1888,7 +1897,7 @@ static void mhi_dev_process_reset_cmd(struct mhi_dev *mhi, int ch_id) } ch = &mhi->ch[ch_id]; - mhi_log(MHI_MSG_VERBOSE, "Processing reset cmd for ch%d\n", ch_id); + mhi_log(MHI_MSG_VERBOSE, "Processing reset cmd for ch_id:%d\n", ch_id); /* * Ensure that the completions that are present in the flush list are * removed from the list and added to event req list before channel @@ -1946,18 +1955,18 @@ static int mhi_dev_process_cmd_ring(struct mhi_dev *mhi, union mhi_dev_ring_ctx *evt_ctx; ch_id = el->generic.chid; - mhi_log(MHI_MSG_VERBOSE, "for channel:%d and cmd:%d\n", + mhi_log(MHI_MSG_VERBOSE, "for ch_id:%d and cmd %d\n", ch_id, el->generic.type); switch (el->generic.type) { case MHI_DEV_RING_EL_START: - mhi_log(MHI_MSG_VERBOSE, "received start cmd for channel %d\n", + mhi_log(MHI_MSG_VERBOSE, "received start cmd for ch_id:%d\n", ch_id); if (ch_id >= (HW_CHANNEL_BASE)) { rc = mhi_hwc_chcmd(mhi, ch_id, el->generic.type); if (rc) { mhi_log(MHI_MSG_ERROR, - "Error with HW channel cmd %d\n", rc); + "Error with HW ch cmd %d\n", rc); rc = mhi_dev_send_cmd_comp_event(mhi, MHI_CMD_COMPL_CODE_UNDEFINED); if (rc) @@ -1970,7 +1979,7 @@ static int mhi_dev_process_cmd_ring(struct mhi_dev *mhi, rc = mhi_dev_mmio_enable_chdb_a7(mhi, ch_id); if (rc) { mhi_log(MHI_MSG_VERBOSE, - "Failed to enable chdb for ch %d\n", + "Failed to enable chdb for ch_id:%d\n", ch_id); goto send_undef_completion_event; } @@ -1985,7 +1994,7 @@ static int mhi_dev_process_cmd_ring(struct mhi_dev *mhi, mhi); if (rc) { mhi_log(MHI_MSG_ERROR, - "start ring failed for ch %d\n", ch_id); + "start ring failed for ch_id:%d\n", ch_id); goto send_undef_completion_event; } @@ -2010,7 +2019,7 @@ static int mhi_dev_process_cmd_ring(struct mhi_dev *mhi, rc = mhi_ring_start(evt_ring, evt_ctx, mhi); if (rc) { mhi_log(MHI_MSG_ERROR, - "error starting event ring %d\n", + "error starting event ring_id:%d\n", mhi->ch_ctx_cache[ch_id].err_indx); goto send_undef_completion_event; } @@ -2034,7 +2043,8 @@ send_start_completion_event: MHI_CMD_COMPL_CODE_SUCCESS); if (rc) mhi_log(MHI_MSG_ERROR, - "Error sending command completion event\n"); + "Error sending compl event for ch_id:%d\n", + ch_id); mhi_update_state_info_ch(ch_id, MHI_STATE_CONNECTED); /* Trigger callback to clients */ @@ -2060,7 +2070,8 @@ send_undef_completion_event: rc = mhi_hwc_chcmd(mhi, ch_id, el->generic.type); if (rc) mhi_log(MHI_MSG_ERROR, - "send channel stop cmd event failed\n"); + "send ch stop cmd event failed for ch_id:%d\n", + ch_id); /* send the completion event to the host */ event.evt_cmd_comp.ptr = mhi->cmd_ctx_cache->rbase + @@ -2092,7 +2103,8 @@ send_undef_completion_event: ring = &mhi->ring[ch_id + mhi->ch_ring_start]; if (ring->state == RING_STATE_UINT) { mhi_log(MHI_MSG_ERROR, - "Channel not opened for %d\n", ch_id); + "Channel not opened for ch_id:%d\n", + ch_id); return -EINVAL; } @@ -2125,7 +2137,8 @@ send_undef_completion_event: rc = mhi_hwc_chcmd(mhi, ch_id, el->generic.type); if (rc) mhi_log(MHI_MSG_ERROR, - "send channel stop cmd event failed\n"); + "send ch stop cmd event failed ch_id:%d\n", + ch_id); /* send the completion event to the host */ event.evt_cmd_comp.ptr = mhi->cmd_ctx_cache->rbase + @@ -2143,7 +2156,8 @@ send_undef_completion_event: rc = mhi_dev_flush_cmd_completion_events(mhi, &event); if (rc) { mhi_log(MHI_MSG_ERROR, - "stop event send failed\n"); + "stop event send failed for ch_id:%d\n", + ch_id); return rc; } } else { @@ -2155,7 +2169,8 @@ send_undef_completion_event: ring = &mhi->ring[ch_id + mhi->ch_ring_start]; if (ring->state == RING_STATE_UINT) { mhi_log(MHI_MSG_ERROR, - "Channel not opened for %d\n", ch_id); + "Channel not opened for ch_id:%d\n", + ch_id); return -EINVAL; } ch = &mhi->ch[ch_id]; @@ -2163,7 +2178,7 @@ send_undef_completion_event: mutex_lock(&ch->ring->event_lock); if (ch->db_pending) { mhi_log(MHI_MSG_ERROR, - "skipping reset cmd ack for channel %d\n", + "skipping reset cmd ack for ch_id:%d\n", ch_id); ch->reset_pending = true; mutex_unlock(&ch->ring->event_lock); @@ -2182,7 +2197,8 @@ send_undef_completion_event: break; default: mhi_log(MHI_MSG_ERROR, - "Invalid command:%d\n", el->generic.type); + "Invalid command:%d, ch_id:%d\n", + el->generic.type, ch_id); break; } return rc; @@ -2197,7 +2213,7 @@ static int mhi_dev_process_tre_ring(struct mhi_dev *mhi, if (ring->id < mhi->ch_ring_start) { mhi_log(MHI_MSG_VERBOSE, - "invalid channel ring id (%d), should be < %lu\n", + "invalid channel ring_id:%d, should be < %lu\n", ring->id, mhi->ch_ring_start); return -EINVAL; } @@ -2236,11 +2252,11 @@ static void mhi_dev_process_ring_pending(struct work_struct *work) list_for_each_safe(cp, q, &mhi->process_ring_list) { ring = list_entry(cp, struct mhi_dev_ring, list); list_del(cp); - mhi_log(MHI_MSG_VERBOSE, "processing ring %d\n", ring->id); + mhi_log(MHI_MSG_VERBOSE, "processing ring_id:%d\n", ring->id); if (ring->id < mhi->ch_ring_start) { mhi_log(MHI_MSG_ERROR, - "ring (%d) is not a channel ring\n", ring->id); + "ring_id:%d is not a channel ring\n", ring->id); goto exit; } @@ -2249,7 +2265,7 @@ static void mhi_dev_process_ring_pending(struct work_struct *work) rc = mhi_dev_process_ring(ring); if (rc) { mhi_log(MHI_MSG_ERROR, - "error processing ring %d\n", ring->id); + "error processing ring_id:%d\n", ring->id); goto exit; } mutex_lock(&ch->ch_lock); @@ -2264,7 +2280,7 @@ static void mhi_dev_process_ring_pending(struct work_struct *work) */ ch_id = ch->ch_id; mhi_log(MHI_MSG_VERBOSE, - "processing pending ch:%d reset\n", ch_id); + "processing pending ch_id:%d reset\n", ch_id); rc = mhi_dev_process_ring( &mhi->ring[mhi->cmd_ring_idx]); if (rc) { @@ -2325,7 +2341,8 @@ static bool mhi_dev_queue_channel_db(struct mhi_dev *mhi, if (chintr_value & 1) { ring = &mhi->ring[ch_num + mhi->ch_ring_start]; if (ring->state == RING_STATE_UINT) { - pr_debug("Channel not opened for %d\n", ch_num); + pr_debug("Channel not opened for ch_id:%d\n", + ch_num); continue; } mhi_ring_set_state(ring, RING_STATE_PENDING); @@ -2449,7 +2466,7 @@ static int mhi_dev_abort(struct mhi_dev *mhi) rc = mhi_dev_mmio_mask_chdb_interrupts(mhi_ctx); if (rc) { mhi_log(MHI_MSG_ERROR, - "Failed to enable channel db\n"); + "Failed to enable ch db\n"); return rc; } @@ -2518,11 +2535,11 @@ static void mhi_dev_transfer_completion_cb(void *mreq) ch->state == MHI_DEV_CH_STOPPED) { if (inbound) mhi_log(MHI_MSG_DBG, - "Ch %d closed with %d writes pending\n", + "ch_id:%d closed with %d writes pending\n", ch->ch_id, ch->pend_wr_count + 1); else mhi_log(MHI_MSG_DBG, - "Ch %d closed with read pending\n", ch->ch_id); + "ch_id:%d closed with read pending\n", ch->ch_id); return; } @@ -2533,7 +2550,7 @@ static void mhi_dev_transfer_completion_cb(void *mreq) /* Flush read completions to host */ if (snd_cmpl && mhi_ctx->ch_ctx_cache[ch->ch_id].ch_type == MHI_DEV_CH_TYPE_OUTBOUND_CHANNEL) { - mhi_log(MHI_MSG_DBG, "Calling flush for ch %d\n", ch->ch_id); + mhi_log(MHI_MSG_DBG, "Calling flush for ch_id:%d\n", ch->ch_id); rc = mhi_dev_flush_transfer_completion_events(mhi_ctx, ch); if (rc) { mhi_log(MHI_MSG_ERROR, @@ -2546,7 +2563,7 @@ static void mhi_dev_transfer_completion_cb(void *mreq) rc = mhi_dev_process_stop_cmd(ch->ring, ch->ch_id, mhi_ctx); if (rc) mhi_log(MHI_MSG_ERROR, - "Error while stopping channel (%d)\n", ch->ch_id); + "Error while stopping ch_id:%d\n", ch->ch_id); } } @@ -2742,7 +2759,7 @@ static int mhi_dev_cache_host_cfg(struct mhi_dev *mhi) /* Get Channel, event and command context base pointer */ rc = mhi_dev_mmio_get_chc_base(mhi); if (rc) { - mhi_log(MHI_MSG_ERROR, "Fetching channel context failed\n"); + mhi_log(MHI_MSG_ERROR, "Fetching ch context failed\n"); return rc; } @@ -3114,7 +3131,7 @@ static int mhi_dev_alloc_evt_buf_evt_req(struct mhi_dev *mhi, if (!size) { mhi_log(MHI_MSG_ERROR, - "Evt buf size is 0 for channel %d", ch->ch_id); + "Evt buf size is 0 for ch_id:%d", ch->ch_id); return -EINVAL; } @@ -3139,13 +3156,13 @@ static int mhi_dev_alloc_evt_buf_evt_req(struct mhi_dev *mhi, ch->evt_req_size = size; mhi_log(MHI_MSG_INFO, - "Channel %d evt buf size is %d\n", ch->ch_id, ch->evt_buf_size); + "ch_id:%d evt buf size is %d\n", ch->ch_id, ch->evt_buf_size); /* Allocate event requests */ ch->ereqs = kcalloc(ch->evt_req_size, sizeof(*ch->ereqs), GFP_KERNEL); if (!ch->ereqs) { mhi_log(MHI_MSG_ERROR, - "Failed to alloc ereqs for Channel %d\n", ch->ch_id); + "Failed to alloc ereqs for ch_id:%d\n", ch->ch_id); rc = -ENOMEM; goto free_ereqs; } @@ -3155,7 +3172,7 @@ static int mhi_dev_alloc_evt_buf_evt_req(struct mhi_dev *mhi, GFP_KERNEL); if (!ch->tr_events) { mhi_log(MHI_MSG_ERROR, - "Failed to alloc tr_events buffer for Channel %d\n", + "Failed to alloc tr_events buffer for ch_id:%d\n", ch->ch_id); rc = -ENOMEM; goto free_ereqs; @@ -3212,7 +3229,7 @@ int mhi_dev_open_channel(uint32_t chan_id, if (ch->active_client) { mhi_log(MHI_MSG_ERROR, - "Channel (%d) already opened by client\n", chan_id); + "ch_id:%d already opened by client\n", chan_id); rc = -EINVAL; goto exit; } @@ -3260,7 +3277,7 @@ int mhi_dev_channel_isempty(struct mhi_dev_client *handle) int rc; if (!handle) { - mhi_log(MHI_MSG_ERROR, "Invalid channel access\n"); + mhi_log(MHI_MSG_ERROR, "Invalid ch access\n"); return -EINVAL; } @@ -3279,7 +3296,7 @@ bool mhi_dev_channel_has_pending_write(struct mhi_dev_client *handle) struct mhi_dev_channel *ch; if (!handle) { - mhi_log(MHI_MSG_ERROR, "Invalid channel access\n"); + mhi_log(MHI_MSG_ERROR, "Invalid ch access\n"); return -EINVAL; } @@ -3298,7 +3315,7 @@ void mhi_dev_close_channel(struct mhi_dev_client *handle) int rc = 0; struct event_req *itr, *tmp; if (!handle) { - mhi_log(MHI_MSG_ERROR, "Invalid channel access:%d\n", -ENODEV); + mhi_log(MHI_MSG_ERROR, "Invalid ch access:%d\n", -ENODEV); return; } ch = handle->channel; @@ -3319,17 +3336,17 @@ void mhi_dev_close_channel(struct mhi_dev_client *handle) } while (++count < MHI_DEV_CH_CLOSE_TIMEOUT_COUNT); if (ch->pend_wr_count) - mhi_log(MHI_MSG_ERROR, "%d writes pending for channel %d\n", + mhi_log(MHI_MSG_ERROR, "%d writes pending for ch_id:%d\n", ch->pend_wr_count, ch->ch_id); if (!list_empty(&ch->event_req_buffers)) - mhi_log(MHI_MSG_ERROR, "%d pending flush for channel %d\n", + mhi_log(MHI_MSG_ERROR, "%d pending flush for ch_id:%d\n", ch->pend_wr_count, ch->ch_id); if (ch->state != MHI_DEV_CH_PENDING_START) if ((ch->ch_type == MHI_DEV_CH_TYPE_OUTBOUND_CHANNEL && !mhi_dev_channel_isempty(handle)) || ch->tre_loc) mhi_log(MHI_MSG_DBG, - "Trying to close an active channel (%d)\n", + "Trying to close an active ch_id:%d\n", ch->ch_id); if (!list_empty(&ch->flush_event_req_buffers)) { @@ -3401,7 +3418,7 @@ int mhi_dev_read_channel(struct mhi_req *mreq) if (mhi_ctx->ctrl_info != MHI_STATE_CONNECTED) { mhi_log(MHI_MSG_ERROR, - "Channel not connected:%d\n", mhi_ctx->ctrl_info); + "ch not connected:%d\n", mhi_ctx->ctrl_info); return -ENODEV; } @@ -3412,7 +3429,7 @@ int mhi_dev_read_channel(struct mhi_req *mreq) if (atomic_read(&mhi_ctx->is_suspended)) { mhi_log(MHI_MSG_ERROR, - "mhi still in suspend, return %d for read ch:%d\n", + "mhi still in suspend, return %d for read ch_id:%d\n", rc, mreq->client->channel->ch_id); return -ENODEV; } @@ -3428,7 +3445,7 @@ int mhi_dev_read_channel(struct mhi_req *mreq) do { if (ch->state == MHI_DEV_CH_STOPPED || ch->reset_pending) { mhi_log(MHI_MSG_VERBOSE, - "channel (%d) already stopped or RST pending\n", + "ch_id:%d already stopped or RST pending\n", mreq->chan); bytes_read = -1; goto exit; @@ -3475,13 +3492,13 @@ int mhi_dev_read_channel(struct mhi_req *mreq) mreq->el = el; mreq->transfer_len = bytes_to_read; mreq->rd_offset = ring->rd_offset; - mhi_log(MHI_MSG_VERBOSE, "reading %lu bytes from chan %d\n", + mhi_log(MHI_MSG_VERBOSE, "reading %lu bytes from ch_id:%d\n", bytes_to_read, mreq->chan); rc = mhi_ctx->host_to_device((void *) write_to_loc, read_from_loc, bytes_to_read, mhi_ctx, mreq); if (rc) { mhi_log(MHI_MSG_ERROR, - "Error while reading chan (%d) rc %d\n", + "Error while reading ch_id:%d rc %d\n", mreq->chan, rc); mutex_unlock(&ch->ch_lock); return rc; @@ -3502,7 +3519,7 @@ int mhi_dev_read_channel(struct mhi_req *mreq) rc = mhi_dev_process_stop_cmd(ring, mreq->chan, mhi_ctx); if (rc) { mhi_log(MHI_MSG_ERROR, - "Error while stopping channel (%d)\n", + "Error while stopping ch_id:%d\n", mreq->chan); bytes_read = -EIO; } @@ -3559,7 +3576,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) if (mhi_ctx->ctrl_info != MHI_STATE_CONNECTED) { mhi_log(MHI_MSG_ERROR, - "Channel not connected:%d\n", mhi_ctx->ctrl_info); + "ch not connected:%d\n", mhi_ctx->ctrl_info); return -ENODEV; } @@ -3574,7 +3591,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) * to the MHI core -> notify SM. */ mutex_lock(&mhi_ctx->mhi_lock); - mhi_log(MHI_MSG_CRITICAL, "Wakeup by chan:%d\n", ch->ch_id); + mhi_log(MHI_MSG_CRITICAL, "Wakeup by ch_id:%d\n", ch->ch_id); rc = mhi_dev_notify_sm_event(MHI_DEV_EVENT_CORE_WAKEUP); if (rc) { mhi_log(MHI_MSG_ERROR, @@ -3607,7 +3624,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) rc = mhi_ctrl_state_info(ch->ch_id, &info); if (rc || (info != MHI_STATE_CONNECTED)) { - mhi_log(MHI_MSG_ERROR, "Channel %d not started by host\n", + mhi_log(MHI_MSG_ERROR, "ch_id %d not started by host\n", ch->ch_id); mutex_unlock(&ch->ch_lock); mutex_unlock(&mhi_ctx->mhi_write_test); @@ -3617,7 +3634,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) ch->pend_wr_count++; if (ch->state == MHI_DEV_CH_STOPPED || ch->reset_pending) { mhi_log(MHI_MSG_ERROR, - "channel %d already stopped or RST pending\n", + "ch_id:%d already stopped or RST pending\n", wreq->chan); bytes_written = -1; goto exit; @@ -3635,7 +3652,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) do { if (ring->rd_offset == ring->wr_offset) { mhi_log(MHI_MSG_ERROR, - "rd & wr offsets are equal for channel-id %d\n", + "rd & wr offsets are equal for ch_id:%d\n", wreq->chan); mhi_log(MHI_MSG_INFO, "No TREs available\n"); break; @@ -3664,7 +3681,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) mhi_ctx, wreq); if (rc) { mhi_log(MHI_MSG_ERROR, - "Error while writing chan (%d) rc %d\n", + "Error while writing ch_id:%d rc %d\n", wreq->chan, rc); goto exit; } else if (wreq->mode == DMA_ASYNC) @@ -3687,7 +3704,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) ring->rd_offset, bytes_to_write, code); if (rc) { mhi_log(MHI_MSG_VERBOSE, - "err in snding cmpl evt ch:%d\n", + "err in snding cmpl evt ch_id:%d\n", wreq->chan); } mhi_dev_ring_inc_index(ring, ring->rd_offset); @@ -3705,7 +3722,7 @@ int mhi_dev_write_channel(struct mhi_req *wreq) rc = mhi_dev_process_stop_cmd(ring, wreq->chan, mhi_ctx); if (rc) { mhi_log(MHI_MSG_ERROR, - "channel %d stop failed\n", wreq->chan); + "ch_id:%d stop failed\n", wreq->chan); } } exit: @@ -3930,7 +3947,7 @@ int mhi_register_state_cb(void (*mhi_state_cb) return -ENXIO; if (channel >= MHI_MAX_SOFTWARE_CHANNELS) { - mhi_log(MHI_MSG_ERROR, "Invalid channel :%d\n", channel); + mhi_log(MHI_MSG_ERROR, "Invalid ch_id:%d\n", channel); return -EINVAL; } @@ -4492,20 +4509,20 @@ static int mhi_edma_init(struct device *dev) mhi_ctx->tx_dma_chan = dma_request_slave_channel(dev, "tx"); if (IS_ERR_OR_NULL(mhi_ctx->tx_dma_chan)) { mhi_log(MHI_MSG_ERROR, - "request for TX chan failed\n"); + "request for TX ch failed\n"); return -EIO; } - mhi_log(MHI_MSG_VERBOSE, "request for TX chan returned :%pK\n", + mhi_log(MHI_MSG_VERBOSE, "request for TX ch returned :%pK\n", mhi_ctx->tx_dma_chan); mhi_ctx->rx_dma_chan = dma_request_slave_channel(dev, "rx"); if (IS_ERR_OR_NULL(mhi_ctx->rx_dma_chan)) { mhi_log(MHI_MSG_ERROR, - "request for RX chan failed\n"); + "request for RX ch failed\n"); return -EIO; } - mhi_log(MHI_MSG_VERBOSE, "request for RX chan returned :%pK\n", + mhi_log(MHI_MSG_VERBOSE, "request for RX ch returned :%pK\n", mhi_ctx->rx_dma_chan); return 0; } diff --git a/drivers/platform/msm/mhi_dev/mhi_dev_net.c b/drivers/platform/msm/mhi_dev/mhi_dev_net.c index ac236edfe928..d05bbe5f1f4f 100644 --- a/drivers/platform/msm/mhi_dev/mhi_dev_net.c +++ b/drivers/platform/msm/mhi_dev/mhi_dev_net.c @@ -121,7 +121,7 @@ static int mhi_dev_net_init_ch_attributes(struct mhi_dev_net_ctxt *mhi_ctxt) chan_attrib->dir = MHI_DIR_OUT; chan_attrib->chan_id = channel; chan_attrib->max_packet_size = TRB_MAX_DATA_SIZE; - mhi_dev_net_log(MHI_INFO, "Write chan attributes dir %d chan_id %d\n", + mhi_dev_net_log(MHI_INFO, "Write ch attributes dir %d ch_id:%d\n", chan_attrib->dir, chan_attrib->chan_id); channel = MHI_CLIENT_IP_SW_4_IN; @@ -129,7 +129,7 @@ static int mhi_dev_net_init_ch_attributes(struct mhi_dev_net_ctxt *mhi_ctxt) chan_attrib->dir = MHI_DIR_IN; chan_attrib->chan_id = channel; chan_attrib->max_packet_size = TRB_MAX_DATA_SIZE; - mhi_dev_net_log(MHI_INFO, "Read chan attributes dir %d chan_id %d\n", + mhi_dev_net_log(MHI_INFO, "Read ch attributes dir %d ch_id %d\n", chan_attrib->dir, chan_attrib->chan_id); return 0; } @@ -299,7 +299,7 @@ static ssize_t mhi_dev_net_client_read(struct mhi_dev_net_client *mhi_handle) if (bytes_avail < 0) { mhi_dev_net_log(MHI_ERROR, - "Failed to read chan %d bytes_avail = %d\n", + "Failed to read ch_id:%d bytes_avail = %d\n", chan, bytes_avail); spin_lock_irqsave(&mhi_handle->rd_lock, flags); kfree_skb(skb); @@ -513,18 +513,18 @@ static int mhi_dev_net_open_chan_create_netif(struct mhi_dev_net_client *client) struct list_head *cp, *q; struct mhi_req *mreq; - mhi_dev_net_log(MHI_DBG, "opening OUT %d IN %d channels\n", + mhi_dev_net_log(MHI_DBG, "opening OUT ch_id:%d IN ch_id:%d channels\n", client->out_chan, client->in_chan); mhi_dev_net_log(MHI_DBG, - "Initializing inbound chan %d.\n", + "Initializing inbound ch_id:%d.\n", client->in_chan); rc = mhi_dev_open_channel(client->out_chan, &client->out_handle, mhi_net_ctxt.net_event_notifier); if (rc < 0) { mhi_dev_net_log(MHI_ERROR, - "Failed to open chan %d, ret 0x%x\n", + "Failed to open ch_id:%d, ret 0x%x\n", client->out_chan, rc); goto handle_not_rdy_err; } else @@ -534,13 +534,13 @@ static int mhi_dev_net_open_chan_create_netif(struct mhi_dev_net_client *client) mhi_net_ctxt.net_event_notifier); if (rc < 0) { mhi_dev_net_log(MHI_ERROR, - "Failed to open chan %d, ret 0x%x\n", + "Failed to open ch_id:%d, ret 0x%x\n", client->in_chan, rc); goto handle_in_err; } else atomic_set(&client->tx_enabled, 1); - mhi_dev_net_log(MHI_INFO, "IN %d, OUT %d channels are opened", + mhi_dev_net_log(MHI_INFO, "IN ch_id:%d, OUT ch_id:%d channels are opened", client->in_chan, client->out_chan); INIT_LIST_HEAD(&client->rx_buffers); @@ -612,7 +612,8 @@ static int mhi_dev_net_rgstr_client(struct mhi_dev_net_client *client, int idx) mutex_init(&client->out_chan_lock); spin_lock_init(&client->wrt_lock); spin_lock_init(&client->rd_lock); - mhi_dev_net_log(MHI_INFO, "Registering out %d, In %d channels\n", + mhi_dev_net_log(MHI_INFO, "Registering OUT ch_id:%d\t" + "IN ch_id:%d channels\n", client->out_chan, client->in_chan); return 0; } @@ -653,20 +654,20 @@ static void mhi_dev_net_state_cb(struct mhi_dev_client_cb_data *cb_data) ret = mhi_ctrl_state_info(mhi_client->in_chan, &info_in_ch); if (ret) { mhi_dev_net_log(MHI_ERROR, - "Failed to obtain in_channel %d state\n", + "Failed to obtain IN ch_id:%d state\n", mhi_client->in_chan); return; } ret = mhi_ctrl_state_info(mhi_client->out_chan, &info_out_ch); if (ret) { mhi_dev_net_log(MHI_ERROR, - "Failed to obtain out_channel %d state\n", + "Failed to obtain OUT ch_id:%d state\n", mhi_client->out_chan); return; } - mhi_dev_net_log(MHI_MSG_VERBOSE, "in_channel :%d, state :%d\n", + mhi_dev_net_log(MHI_MSG_VERBOSE, "IN ch_id::%d, state :%d\n", mhi_client->in_chan, info_in_ch); - mhi_dev_net_log(MHI_MSG_VERBOSE, "out_channel :%d, state :%d\n", + mhi_dev_net_log(MHI_MSG_VERBOSE, "OUT ch_id:%d, state :%d\n", mhi_client->out_chan, info_out_ch); if (info_in_ch == MHI_STATE_CONNECTED && info_out_ch == MHI_STATE_CONNECTED) { diff --git a/drivers/platform/msm/mhi_dev/mhi_mmio.c b/drivers/platform/msm/mhi_dev/mhi_mmio.c index 44f64b679cb5..a306b58511c1 100644 --- a/drivers/platform/msm/mhi_dev/mhi_mmio.c +++ b/drivers/platform/msm/mhi_dev/mhi_mmio.c @@ -101,7 +101,7 @@ static int mhi_dev_mmio_mask_set_chdb_int_a7(struct mhi_dev *dev, chid_idx = chdb_id/32; if (chid_idx >= MHI_MASK_ROWS_CH_EV_DB) { - mhi_log(MHI_MSG_ERROR, "Invalid channel id:%d\n", chid_idx); + mhi_log(MHI_MSG_ERROR, "Invalid ch_id:%d\n", chid_idx); return -EINVAL; } diff --git a/drivers/platform/msm/mhi_dev/mhi_ring.c b/drivers/platform/msm/mhi_dev/mhi_ring.c index 9ef1134c0eca..06d18c81e9ce 100644 --- a/drivers/platform/msm/mhi_dev/mhi_ring.c +++ b/drivers/platform/msm/mhi_dev/mhi_ring.c @@ -94,7 +94,7 @@ int mhi_dev_cache_ring(struct mhi_dev_ring *ring, size_t wr_offset) if (ring->wr_offset == wr_offset) { mhi_log(MHI_MSG_VERBOSE, - "nothing to cache for ring %d, local wr_ofst %lu\n", + "nothing to cache for ring_id:%d, local wr_ofst %lu\n", ring->id, ring->wr_offset); mhi_log(MHI_MSG_VERBOSE, "new wr_offset %lu\n", wr_offset); @@ -112,16 +112,16 @@ int mhi_dev_cache_ring(struct mhi_dev_ring *ring, size_t wr_offset) ring->id < (mhi_ctx->ev_ring_start + mhi_ctx->cfg.event_rings)) { mhi_log(MHI_MSG_VERBOSE, - "not caching event ring %d\n", ring->id); + "not caching event ring_id:%d\n", ring->id); return 0; } - mhi_log(MHI_MSG_VERBOSE, "caching ring %d, start %lu, end %lu\n", + mhi_log(MHI_MSG_VERBOSE, "caching ring_id:%d, start %lu, end %lu\n", ring->id, old_offset, wr_offset); if (mhi_dev_fetch_ring_elements(ring, old_offset, wr_offset)) { mhi_log(MHI_MSG_ERROR, - "failed to fetch elements for ring %d, start %lu, end %lu\n", + "failed to fetch elements for ring_id:%d, start %lu, end %lu\n", ring->id, old_offset, wr_offset); return -EINVAL; } @@ -147,7 +147,7 @@ int mhi_dev_update_wr_offset(struct mhi_dev_ring *ring) return rc; } mhi_log(MHI_MSG_VERBOSE, - "ring %d wr_offset from db 0x%lx\n", + "ring_id:%d wr_offset from db 0x%lx\n", ring->id, (size_t) wr_offset); break; case RING_TYPE_ER: @@ -164,7 +164,7 @@ int mhi_dev_update_wr_offset(struct mhi_dev_ring *ring) return rc; } mhi_log(MHI_MSG_VERBOSE, - "ring %d wr_offset from db 0x%lx\n", + "ring_id:%d wr_offset from db 0x%lx\n", ring->id, (size_t) wr_offset); break; default: @@ -202,7 +202,7 @@ int mhi_dev_process_ring_element(struct mhi_dev_ring *ring, size_t offset) if (ring->ring_cb) return ring->ring_cb(ring->mhi_dev, el, (void *)ring); else - mhi_log(MHI_MSG_ERROR, "No callback registered for ring %d\n", + mhi_log(MHI_MSG_ERROR, "No callback registered for ring_id:%d\n", ring->id); return 0; @@ -217,19 +217,19 @@ int mhi_dev_process_ring(struct mhi_dev_ring *ring) return -EINVAL; mhi_log(MHI_MSG_VERBOSE, - "Before wr update ring_id (%d) rp:%lu wp:%lu\n", + "Before wr update ring_id:%d rp:%lu wp:%lu\n", ring->id, ring->rd_offset, ring->wr_offset); rc = mhi_dev_update_wr_offset(ring); if (rc) { mhi_log(MHI_MSG_ERROR, - "Error updating write-offset for ring %d\n", + "Error updating write-offset for ring_id:%d\n", ring->id); return rc; } mhi_log(MHI_MSG_VERBOSE, - "After wp update ring_id (%d) rp:%lu with wr:%lu\n", + "After wp update ring_id:%d rp:%lu with wr:%lu\n", ring->id, ring->rd_offset, ring->wr_offset); /* @@ -247,13 +247,13 @@ int mhi_dev_process_ring(struct mhi_dev_ring *ring) while (ring->rd_offset != ring->wr_offset) { mhi_log(MHI_MSG_VERBOSE, - "Processing ring (%d) rd_offset:%lu, wr_offset:%lu\n", + "Processing ring_id:%d rd_offset:%lu, wr_offset:%lu\n", ring->id, ring->rd_offset, ring->wr_offset); rc = mhi_dev_process_ring_element(ring, ring->rd_offset); if (rc) { mhi_log(MHI_MSG_ERROR, - "Error processing ring (%d) element(rp) (%lu)\n", + "Error processing ring_id:%d element(rp):%lu\n", ring->id, ring->rd_offset); return rc; } @@ -298,7 +298,7 @@ int mhi_dev_add_element(struct mhi_dev_ring *ring, ring->wr_offset - 1; if (num_free_elem < num_elem) { - mhi_log(MHI_MSG_ERROR, "No space to add %d elem in ring (%d)\n", + mhi_log(MHI_MSG_ERROR, "No space to add %d elem in ring_id:%d\n", num_elem, ring->id); return -EINVAL; } @@ -313,8 +313,9 @@ int mhi_dev_add_element(struct mhi_dev_ring *ring, mhi_dev_ring_inc_index(ring, ring->rd_offset); mhi_log(MHI_MSG_VERBOSE, - "Writing %d elements, ring old 0x%x, new 0x%x\n", - num_elem, old_offset, ring->rd_offset); + "Writing %d elements in ring_id:%d\t" + "ring old-offset 0x%x, new-offset 0x%x\n", + num_elem, ring->id, old_offset, ring->rd_offset); ring->ring_ctx->generic.rp = (ring->rd_offset * sizeof(union mhi_dev_ring_element_type)) + @@ -336,7 +337,7 @@ int mhi_dev_add_element(struct mhi_dev_ring *ring, host_addr.virt_addr = element; host_addr.size = sizeof(union mhi_dev_ring_element_type); - mhi_log(MHI_MSG_VERBOSE, "adding element to ring (%d)\n", + mhi_log(MHI_MSG_VERBOSE, "adding element to ring_id:%d\n", ring->id); mhi_log(MHI_MSG_VERBOSE, "rd_ofset %lu\n", ring->rd_offset); mhi_log(MHI_MSG_VERBOSE, "type %d\n", element->generic.type); @@ -356,7 +357,7 @@ int mhi_dev_add_element(struct mhi_dev_ring *ring, (element + i)->evt_tr_comp.code); mhi_log(MHI_MSG_VERBOSE, "evnt type :0x%x\n", (element + i)->evt_tr_comp.type); - mhi_log(MHI_MSG_VERBOSE, "evnt chid :0x%x\n", + mhi_log(MHI_MSG_VERBOSE, "evnt ch_id :0x%x\n", (element + i)->evt_tr_comp.chid); } /* Adding multiple ring elements */ diff --git a/drivers/platform/msm/mhi_dev/mhi_uci.c b/drivers/platform/msm/mhi_dev/mhi_uci.c index 2b458e130201..53ddfc75ab42 100644 --- a/drivers/platform/msm/mhi_dev/mhi_uci.c +++ b/drivers/platform/msm/mhi_dev/mhi_uci.c @@ -452,7 +452,7 @@ static bool mhi_uci_are_channels_connected(struct uci_client *uci_client) rc = mhi_ctrl_state_info(uci_client->in_chan, &info_ch_in); if (rc) { uci_log(UCI_DBG_DBG, - "Channels %d is not available with %d\n", + "ch_id:%d is not available with %d\n", uci_client->out_chan, rc); return false; } @@ -460,7 +460,7 @@ static bool mhi_uci_are_channels_connected(struct uci_client *uci_client) rc = mhi_ctrl_state_info(uci_client->out_chan, &info_ch_out); if (rc) { uci_log(UCI_DBG_DBG, - "Channels %d is not available with %d\n", + "ch_id:%d is not available with %d\n", uci_client->out_chan, rc); return false; } @@ -468,7 +468,7 @@ static bool mhi_uci_are_channels_connected(struct uci_client *uci_client) if ((info_ch_in != MHI_STATE_CONNECTED) || (info_ch_out != MHI_STATE_CONNECTED)) { uci_log(UCI_DBG_DBG, - "Channels %d or %d are not connected\n", + "ch_id:%d or %d are not connected\n", uci_client->in_chan, uci_client->out_chan); return false; } @@ -490,13 +490,13 @@ static int mhi_init_read_chan(struct uci_client *client_handle, return -EINVAL; } if (chan >= MHI_MAX_SOFTWARE_CHANNELS) { - uci_log(UCI_DBG_ERROR, "Incorrect channel number %d\n", chan); + uci_log(UCI_DBG_ERROR, "Incorrect ch_id:%d\n", chan); return -EINVAL; } in_chan_attr = client_handle->in_chan_attr; if (!in_chan_attr) { - uci_log(UCI_DBG_ERROR, "Null channel attributes for chan %d\n", + uci_log(UCI_DBG_ERROR, "Null channel attributes for ch_id:%d\n", client_handle->in_chan); return -EINVAL; } @@ -531,7 +531,7 @@ static struct mhi_req *mhi_uci_get_req(struct uci_client *uci_handle) spin_lock_irqsave(&uci_handle->req_lock, flags); if (list_empty(&uci_handle->req_list)) { - uci_log(UCI_DBG_ERROR, "Request pool empty for chans %d, %d\n", + uci_log(UCI_DBG_ERROR, "Request pool empty for ch_id:%d, %d\n", uci_handle->in_chan, uci_handle->out_chan); spin_unlock_irqrestore(&uci_handle->req_lock, flags); return NULL; @@ -546,7 +546,7 @@ static struct mhi_req *mhi_uci_get_req(struct uci_client *uci_handle) * req is re-used */ if (req->is_stale && req->buf && MHI_UCI_IS_CHAN_DIR_IN(req->chan)) { - uci_log(UCI_DBG_VERBOSE, "Freeing write buf for chan %d\n", + uci_log(UCI_DBG_VERBOSE, "Freeing write buf for ch_id:%d\n", req->chan); kfree(req->buf); } @@ -565,7 +565,7 @@ static int mhi_uci_put_req(struct uci_client *uci_handle, struct mhi_req *req) spin_lock_irqsave(&uci_handle->req_lock, flags); if (req->is_stale) { uci_log(UCI_DBG_VERBOSE, - "Got stale completion for ch %d, ignoring\n", + "Got stale completion for ch_id:%d, ignoring\n", req->chan); spin_unlock_irqrestore(&uci_handle->req_lock, flags); return -EINVAL; @@ -630,7 +630,8 @@ static int mhi_uci_send_sync(struct uci_client *uci_handle, int ret_val; uci_log(UCI_DBG_VERBOSE, - "Sync write for ch %d size %d\n", uci_handle->out_chan, size); + "Sync write for ch_id:%d size %d\n", + uci_handle->out_chan, size); ureq.client = uci_handle->out_handle; ureq.buf = data_loc; @@ -652,7 +653,7 @@ static int mhi_uci_send_async(struct uci_client *uci_handle, struct mhi_req *ureq; uci_log(UCI_DBG_DBG, - "Async write for ch %d size %d\n", + "Async write for ch_id:%d size %d\n", uci_handle->out_chan, size); ureq = mhi_uci_get_req(uci_handle); @@ -691,7 +692,7 @@ static int mhi_uci_send_packet(struct uci_client *uci_handle, void *data_loc, ret_val = uci_handle->send(uci_handle, data_loc, size); if (!ret_val) { uci_log(UCI_DBG_VERBOSE, - "No descriptors available, did we poll, chan %d?\n", + "No descriptors available, did we poll, ch_id:%d?\n", uci_handle->out_chan); mutex_unlock(&uci_handle->out_chan_lock); if (uci_handle->f_flags & (O_NONBLOCK | O_NDELAY)) @@ -711,7 +712,7 @@ static int mhi_uci_send_packet(struct uci_client *uci_handle, void *data_loc, * Wait till pending writes complete or a timeout. */ uci_log(UCI_DBG_VERBOSE, - "Write req list empty for chan %d\n", + "Write req list empty for ch_id:%d\n", uci_handle->out_chan); mutex_unlock(&uci_handle->out_chan_lock); if (uci_handle->f_flags & (O_NONBLOCK | O_NDELAY)) @@ -726,14 +727,14 @@ static int mhi_uci_send_packet(struct uci_client *uci_handle, void *data_loc, * retry the write. */ uci_log(UCI_DBG_VERBOSE, - "Write req struct available for chan %d\n", + "Write req struct available for ch_id:%d\n", uci_handle->out_chan); mutex_lock(&uci_handle->out_chan_lock); ret_val = 0; continue; } else if (!ret_val) { uci_log(UCI_DBG_ERROR, - "Timed out waiting for write req, chan %d\n", + "Timed out waiting for write req, ch_id:%d\n", uci_handle->out_chan); return -EIO; } else if (-ERESTARTSYS == ret_val) { @@ -743,7 +744,7 @@ static int mhi_uci_send_packet(struct uci_client *uci_handle, void *data_loc, } } else if (ret_val < 0) { uci_log(UCI_DBG_ERROR, - "Err sending data: chan %d, buf %pK, size %d\n", + "Err sending data: ch_id:%d, buf %pK, size %d\n", uci_handle->out_chan, data_loc, size); ret_val = -EIO; break; @@ -807,18 +808,18 @@ static unsigned int mhi_uci_client_poll(struct file *file, poll_table *wait) if (!atomic_read(&uci_ctxt.mhi_disabled) && !mhi_dev_channel_isempty(uci_handle->in_handle)) { uci_log(UCI_DBG_VERBOSE, - "Client can read chan %d\n", uci_handle->in_chan); + "Client can read ch_id:%d\n", uci_handle->in_chan); mask |= POLLIN | POLLRDNORM; } if (!atomic_read(&uci_ctxt.mhi_disabled) && !mhi_dev_channel_isempty(uci_handle->out_handle)) { uci_log(UCI_DBG_VERBOSE, - "Client can write chan %d\n", uci_handle->out_chan); + "Client can write ch_id:%d\n", uci_handle->out_chan); mask |= POLLOUT | POLLWRNORM; } uci_log(UCI_DBG_VERBOSE, - "Client attempted to poll chan %d, returning mask 0x%x\n", + "Client attempted to poll ch_id:%d, returning mask 0x%x\n", uci_handle->in_chan, mask); mutex_unlock(&uci_handle->client_lock); @@ -853,7 +854,7 @@ static int mhi_uci_alloc_reqs(struct uci_client *client) list_add_tail(&client->reqs[i].list, &client->req_list); uci_log(UCI_DBG_INFO, - "Allocated %d write reqs for chan %d\n", + "Allocated %d write reqs for ch_id:%d\n", num_reqs, client->out_chan); return 0; } @@ -866,12 +867,12 @@ static int mhi_uci_read_async(struct uci_client *uci_handle, int *bytes_avail) struct mhi_dev_client *client_handle; uci_log(UCI_DBG_DBG, - "Async read for ch %d\n", uci_handle->in_chan); + "Async read for ch_id:%d\n", uci_handle->in_chan); ureq = mhi_uci_get_req(uci_handle); if (!ureq) { uci_log(UCI_DBG_ERROR, - "Out of reqs for chan %d\n", uci_handle->in_chan); + "Out of reqs for ch_id:%d\n", uci_handle->in_chan); return -EBUSY; } @@ -917,14 +918,14 @@ static int mhi_uci_read_async(struct uci_client *uci_handle, int *bytes_avail) uci_log(UCI_DBG_ERROR, "Exit signal caught\n"); return compl_ret; } else if (compl_ret == 0) { - uci_log(UCI_DBG_ERROR, "Read timed out for ch %d\n", + uci_log(UCI_DBG_ERROR, "Read timed out for ch_id:%d\n", uci_handle->in_chan); return -EIO; } uci_log(UCI_DBG_VERBOSE, - "wk up Read completed on ch %d\n", uci_handle->in_chan); + "wk up Read completed on ch_id:%d\n", uci_handle->in_chan); uci_log(UCI_DBG_VERBOSE, - "Got pkt of sz 0x%lx at adr %pK, ch %d\n", + "Got pkt of sz 0x%lx at adr %pK, ch_id:%d\n", uci_handle->pkt_size, uci_handle->pkt_loc, uci_handle->in_chan); } else { @@ -945,7 +946,7 @@ static int mhi_uci_read_sync(struct uci_client *uci_handle, int *bytes_avail) struct mhi_dev_client *client_handle; uci_log(UCI_DBG_INFO, - "Sync read for ch %d\n", uci_handle->in_chan); + "Sync read for ch_id:%d\n", uci_handle->in_chan); client_handle = uci_handle->in_handle; ureq.chan = uci_handle->in_chan; @@ -969,7 +970,7 @@ static int mhi_uci_read_sync(struct uci_client *uci_handle, int *bytes_avail) uci_handle->pkt_size = ureq.transfer_len; uci_log(UCI_DBG_VERBOSE, - "Got pkt of sz 0x%lx at adr %pK, ch %d\n", + "Got pkt of sz 0x%lx at adr %pK, ch_id:%d\n", uci_handle->pkt_size, ureq.buf, ureq.chan); } else { @@ -990,7 +991,7 @@ static int open_client_mhi_channels(struct uci_client *uci_client) } uci_log(UCI_DBG_DBG, - "Starting channels %d %d.\n", + "Starting channels OUT ch_id:%d IN ch_id:%d\n", uci_client->out_chan, uci_client->in_chan); mutex_lock(&uci_client->out_chan_lock); @@ -1009,7 +1010,7 @@ static int open_client_mhi_channels(struct uci_client *uci_client) } uci_log(UCI_DBG_DBG, - "Initializing inbound chan %d.\n", + "Initializing inbound ch_id:%d.\n", uci_client->in_chan); rc = mhi_init_read_chan(uci_client, uci_client->in_chan); if (rc < 0) { @@ -1030,7 +1031,7 @@ static int open_client_mhi_channels(struct uci_client *uci_client) uci_ctxt.event_notifier); if (rc < 0) { uci_log(UCI_DBG_ERROR, - "Failed to open chan %d, ret %d\n", + "Failed to open ch_id:%d, ret %d\n", uci_client->out_chan, rc); goto handle_in_err; } @@ -1133,14 +1134,14 @@ static int mhi_uci_client_release(struct inode *mhi_inode, mutex_lock(&uci_handle->client_lock); in_chan_attr = uci_handle->in_chan_attr; if (!in_chan_attr) { - uci_log(UCI_DBG_ERROR, "Null channel attributes for chan %d\n", + uci_log(UCI_DBG_ERROR, "Null channel attributes for ch_id:%d\n", uci_handle->in_chan); mutex_unlock(&uci_handle->client_lock); return -EINVAL; } if (atomic_sub_return(1, &uci_handle->ref_count)) { - uci_log(UCI_DBG_DBG, "Client close chan %d, ref count 0x%x\n", + uci_log(UCI_DBG_DBG, "Client close ch_id:%d, ref count 0x%x\n", iminor(mhi_inode), atomic_read(&uci_handle->ref_count)); mutex_unlock(&uci_handle->client_lock); @@ -1148,7 +1149,7 @@ static int mhi_uci_client_release(struct inode *mhi_inode, } uci_log(UCI_DBG_DBG, - "Last client left, closing channel 0x%x\n", + "Last client left, closing ch 0x%x\n", iminor(mhi_inode)); do { @@ -1160,7 +1161,7 @@ static int mhi_uci_client_release(struct inode *mhi_inode, } while (++count < MHI_UCI_RELEASE_TIMEOUT_COUNT); if (count == MHI_UCI_RELEASE_TIMEOUT_COUNT) { - uci_log(UCI_DBG_DBG, "Channel %d has pending writes\n", + uci_log(UCI_DBG_DBG, "ch_id:%d has pending writes\n", iminor(mhi_inode)); } @@ -1191,7 +1192,7 @@ static int mhi_uci_client_release(struct inode *mhi_inode, list_del_init(&ureq->list); ureq->is_stale = true; uci_log(UCI_DBG_VERBOSE, - "Adding back req for chan %d to free list\n", + "Adding back req for ch_id:%d to free list\n", ureq->chan); list_add_tail(&ureq->list, &uci_handle->req_list); count++; @@ -1256,12 +1257,12 @@ static int mhi_state_uevent(struct device *dev, struct kobj_uevent_env *env) for (i = 0; i < ARRAY_SIZE(mhi_chan_attr_table); i++) { chan_attrib = &mhi_chan_attr_table[i]; if (chan_attrib->state_bcast) { - uci_log(UCI_DBG_INFO, "Calling notify for ch %d\n", + uci_log(UCI_DBG_INFO, "Calling notify for ch_id:%d\n", chan_attrib->chan_id); rc = mhi_ctrl_state_info(chan_attrib->chan_id, &info); if (rc) { uci_log(UCI_DBG_ERROR, - "Failed to obtain channel %d state\n", + "Failed to obtain ch_id:%d state\n", chan_attrib->chan_id); return -EINVAL; } @@ -1343,7 +1344,7 @@ static int __mhi_uci_client_read(struct uci_client *uci_handle, /* If nothing was copied yet, wait for data */ uci_log(UCI_DBG_VERBOSE, - "No data read_data_ready %d, chan %d\n", + "No data read_data_ready %d, ch_id:%d\n", atomic_read(&uci_handle->read_data_ready), uci_handle->in_chan); if (uci_handle->f_flags & (O_NONBLOCK | O_NDELAY)) @@ -1359,13 +1360,13 @@ static int __mhi_uci_client_read(struct uci_client *uci_handle, } uci_log(UCI_DBG_VERBOSE, - "wk up Got data on ch %d read_data_ready %d\n", + "wk up Got data on ch_id:%d read_data_ready %d\n", uci_handle->in_chan, atomic_read(&uci_handle->read_data_ready)); } else if (*bytes_avail > 0) { /* A valid packet was returned from MHI */ uci_log(UCI_DBG_VERBOSE, - "Got packet: avail pkts %d phy_adr %pK, ch %d\n", + "Got packet: avail pkts %d phy_adr %pK, ch_id:%d\n", atomic_read(&uci_handle->read_data_ready), uci_handle->pkt_loc, uci_handle->in_chan); @@ -1398,7 +1399,7 @@ static ssize_t mhi_uci_client_read(struct file *file, char __user *ubuf, mutex = &uci_handle->in_chan_lock; mutex_lock(mutex); - uci_log(UCI_DBG_VERBOSE, "Client attempted read on chan %d\n", + uci_log(UCI_DBG_VERBOSE, "Client attempted read on ch_id:%d\n", uci_handle->in_chan); ret_val = __mhi_uci_client_read(uci_handle, &bytes_avail); @@ -1418,7 +1419,7 @@ static ssize_t mhi_uci_client_read(struct file *file, char __user *ubuf, bytes_copied = *bytes_pending; *bytes_pending = 0; - uci_log(UCI_DBG_VERBOSE, "Copied 0x%lx of 0x%x, chan %d\n", + uci_log(UCI_DBG_VERBOSE, "Copied 0x%lx of 0x%x, ch_id:%d\n", bytes_copied, (u32)*bytes_pending, uci_handle->in_chan); } else { addr_offset = uci_handle->pkt_size - *bytes_pending; @@ -1429,7 +1430,7 @@ static ssize_t mhi_uci_client_read(struct file *file, char __user *ubuf, } bytes_copied = uspace_buf_size; *bytes_pending -= uspace_buf_size; - uci_log(UCI_DBG_VERBOSE, "Copied 0x%lx of 0x%x,chan %d\n", + uci_log(UCI_DBG_VERBOSE, "Copied 0x%lx of 0x%x,ch_id:%d\n", bytes_copied, (u32)*bytes_pending, uci_handle->in_chan); @@ -1437,7 +1438,7 @@ static ssize_t mhi_uci_client_read(struct file *file, char __user *ubuf, /* We finished with this buffer, map it back */ if (*bytes_pending == 0) { uci_log(UCI_DBG_VERBOSE, - "All data consumed. Pkt loc %p ,chan %d\n", + "All data consumed. Pkt loc %p ,ch_id:%d\n", uci_handle->pkt_loc, uci_handle->in_chan); uci_handle->pkt_loc = 0; uci_handle->pkt_size = 0; @@ -1578,7 +1579,7 @@ void mhi_uci_chan_state_notify_all(struct mhi_dev *mhi, for (i = 0; i < ARRAY_SIZE(mhi_chan_attr_table); i++) { chan_attrib = &mhi_chan_attr_table[i]; if (chan_attrib->state_bcast) { - uci_log(UCI_DBG_ERROR, "Calling notify for ch %d\n", + uci_log(UCI_DBG_ERROR, "Calling notify for ch_id:%d\n", chan_attrib->chan_id); mhi_uci_chan_state_notify(mhi, chan_attrib->chan_id, ch_state); @@ -1595,14 +1596,14 @@ void mhi_uci_chan_state_notify(struct mhi_dev *mhi, int rc; if (ch_id < 0 || ch_id >= MHI_MAX_SOFTWARE_CHANNELS) { - uci_log(UCI_DBG_ERROR, "Invalid chan %d\n", ch_id); + uci_log(UCI_DBG_ERROR, "Invalid ch_id:%d\n", ch_id); return; } uci_handle = &uci_ctxt.client_handles[CHAN_TO_CLIENT(ch_id)]; if (!uci_handle->out_chan_attr || !uci_handle->out_chan_attr->state_bcast) { - uci_log(UCI_DBG_VERBOSE, "Uevents not enabled for chan %d\n", + uci_log(UCI_DBG_VERBOSE, "Uevents not enabled for ch_id:%d\n", ch_id); return; } @@ -1628,7 +1629,7 @@ void mhi_uci_chan_state_notify(struct mhi_dev *mhi, rc = kobject_uevent_env(&mhi->dev->kobj, KOBJ_CHANGE, buf); if (rc) uci_log(UCI_DBG_ERROR, - "Sending uevent failed for chan %d\n", ch_id); + "Sending uevent failed for ch_id:%d\n", ch_id); if (ch_state == MHI_STATE_DISCONNECTED && !atomic_read(&uci_handle->ref_count)) { @@ -1674,7 +1675,7 @@ static void uci_event_notifier(struct mhi_dev_client_cb_reason *reason) uci_handle->out_chan_attr->tre_notif_cb(reason); } else if (reason->reason == MHI_DEV_TRE_AVAILABLE) { uci_log(UCI_DBG_DBG, - "recived TRE available event for chan %d\n", + "recived TRE available event for ch_id:%d\n", uci_handle->in_chan); if (reason->ch_id % 2) { atomic_set(&uci_handle->write_data_ready, 1); @@ -1699,7 +1700,7 @@ static int mhi_register_client(struct uci_client *mhi_client, int index) /* Init the completion event for AT ctrl read */ init_completion(&mhi_client->at_ctrl_read_done); - uci_log(UCI_DBG_DBG, "Registering chan %d.\n", mhi_client->out_chan); + uci_log(UCI_DBG_DBG, "Registering ch_id:%d.\n", mhi_client->out_chan); return 0; } @@ -2066,7 +2067,7 @@ static void mhi_uci_at_ctrl_client_cb(struct mhi_dev_client_cb_data *cb_data) int rc, i; struct mhi_req *ureq; - uci_log(UCI_DBG_VERBOSE, " Rcvd MHI cb for channel %d, state %d\n", + uci_log(UCI_DBG_VERBOSE, " Rcvd MHI cb for ch_id:%d, state %d\n", cb_data->channel, cb_data->ctrl_info); if (cb_data->ctrl_info == MHI_STATE_CONNECTED) { @@ -2117,7 +2118,7 @@ static void mhi_uci_generic_client_cb(struct mhi_dev_client_cb_data *cb_data) { struct uci_client *client = cb_data->user_data; - uci_log(UCI_DBG_DBG, "Rcvd MHI cb for channel %d, state %d\n", + uci_log(UCI_DBG_DBG, "Rcvd MHI cb for ch_id:%d, state %d\n", cb_data->channel, cb_data->ctrl_info); if (cb_data->ctrl_info == MHI_STATE_CONNECTED)