Merge "diag: Add debug logs tracing diag mhi read and write paths" (3f97ec58) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/char/diag/diagchar_core.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -4297,7 +4297,7 @@ static void diag_debug_init(void)
		* to be logged to IPC
		*/
		diag_debug_mask = DIAG_DEBUG_PERIPHERALS \| DIAG_DEBUG_DCI \|
		DIAG_DEBUG_USERSPACE \| DIAG_DEBUG_BRIDGE;
		DIAG_DEBUG_MHI \| DIAG_DEBUG_USERSPACE \| DIAG_DEBUG_BRIDGE;
		}
		#else
		static void diag_debug_init(void)

drivers/char/diag/diagfwd_bridge.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -111,7 +111,7 @@ static int diagfwd_bridge_mux_write_done(unsigned char *buf, int len,
		return -EINVAL;
		ch = &bridge_info[buf_ctx];
		if (ch->dev_ops && ch->dev_ops->fwd_complete) {
		DIAG_LOG(DIAG_DEBUG_MHI,
		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		"Write done completion received for buf %pK len:%d\n",
		buf, len);
		ch->dev_ops->fwd_complete(ch->id, ch->ctxt, buf, len, 0);

drivers/char/diag/diagfwd_mhi.c

+72 −32

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/* Copyright (c) 2014-2019, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2014-2020, The Linux Foundation. All rights reserved.
		*/

		#include <linux/slab.h>
		@@ -192,9 +192,12 @@ static void mhi_buf_tbl_remove(struct diag_mhi_info *mhi_info, int type,
		list_del(&item->link);
		if (type == TYPE_MHI_READ_CH) {
		DIAG_LOG(DIAG_DEBUG_MHI,
		"Callback received on buffer:%pK from mhi\n", buf);
		"Freeing read channel buffer: %pK\n", buf);
		diagmem_free(driver, item->buf, mhi_info->mempool);
		}
		DIAG_LOG(DIAG_DEBUG_MHI,
		"Removing %s channel item entry from table: %pK\n",
		mhi_info->name, buf);
		kfree(item);
		found = 1;
		}
		@@ -232,7 +235,7 @@ static void mhi_buf_tbl_clear(struct diag_mhi_info *mhi_info)
		&mhi_info->read_done_list, link) {
		if (tp->buf == buf) {
		DIAG_LOG(DIAG_DEBUG_MHI,
		"buffer:%pK removed from table for ch:%s\n",
		"Read buffer:%pK removed from table for ch:%s\n",
		buf, mhi_info->name);
		list_del(&tp->link);
		kfree(tp);
		@@ -254,6 +257,9 @@ static void mhi_buf_tbl_clear(struct diag_mhi_info *mhi_info)
		item = list_entry(start, struct diag_mhi_buf_tbl_t,
		link);
		list_del(&item->link);
		DIAG_LOG(DIAG_DEBUG_MHI,
		"Write buffer %pK removed from table for ch: %s\n",
		buf, mhi_info->name);
		diag_remote_dev_write_done(mhi_info->dev_id, item->buf,
		item->len, mhi_info->id);
		kfree(item);
		@@ -280,6 +286,9 @@ static int __mhi_close(struct diag_mhi_info *mhi_info, int close_flag)

		if (close_flag == CLOSE_CHANNELS) {
		mutex_lock(&mhi_info->ch_mutex);
		DIAG_LOG(DIAG_DEBUG_MHI,
		"diag: %s mhi channel closed, calling mhi unprepare\n",
		mhi_info->name);
		mhi_unprepare_from_transfer(mhi_info->mhi_dev);
		mutex_unlock(&mhi_info->ch_mutex);
		}
		@@ -293,15 +302,20 @@ static int mhi_close(int token, int ch)
		int dev_idx = get_id_from_token(token);

		if (dev_idx < 0 \|\| dev_idx >= NUM_MHI_DEV) {
		pr_err("diag: In %s, invalid index %d\n", __func__, dev_idx);
		pr_err("diag: %s: invalid index %d\n", __func__, dev_idx);
		return -EINVAL;
		}

		if (ch < 0 \|\| ch >= NUM_MHI_CHAN)
		pr_err("diag: In %s, invalid channel %d\n", __func__, ch);
		if (ch < 0 \|\| ch >= NUM_MHI_CHAN) {
		pr_err("diag: %s: invalid channel %d\n", __func__, ch);
		return -EINVAL;
		}

		if (!diag_mhi[dev_idx][ch].enabled)
		if (!diag_mhi[dev_idx][ch].enabled) {
		pr_err("diag: %s: invalid device node for index: %d, ch: %d\n",
		__func__, dev_idx, ch);
		return -ENODEV;
		}
		/*
		* This function is called whenever the channel needs to be closed
		* explicitly by Diag. Close both the read and write channels (denoted
		@@ -334,9 +348,16 @@ static int __mhi_open(struct diag_mhi_info *mhi_info, int token, int open_flag)
		return -ENODEV;
		if (open_flag == OPEN_CHANNELS) {
		if ((atomic_read(&(mhi_info->read_ch.opened))) &&
		(atomic_read(&(mhi_info->write_ch.opened))))
		(atomic_read(&(mhi_info->write_ch.opened)))) {
		DIAG_LOG(DIAG_DEBUG_MHI,
		"Read and write channel already open: %s\n",
		mhi_info->name);
		return 0;
		}
		mutex_lock(&mhi_info->ch_mutex);
		DIAG_LOG(DIAG_DEBUG_MHI,
		"Prepare mhi for transfer on port: %s\n",
		mhi_info->name);
		err = mhi_prepare_for_transfer(mhi_info->mhi_dev);
		mutex_unlock(&mhi_info->ch_mutex);
		if (err) {
		@@ -346,9 +367,9 @@ static int __mhi_open(struct diag_mhi_info *mhi_info, int token, int open_flag)
		}
		atomic_set(&mhi_info->read_ch.opened, 1);
		atomic_set(&mhi_info->write_ch.opened, 1);
		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		"opened mhi read/write channel, port: %d\n",
		mhi_info->id);
		DIAG_LOG(DIAG_DEBUG_MHI,
		"opened mhi read/write channel, port: %s\n",
		mhi_info->name);
		} else if (open_flag == CHANNELS_OPENED) {
		if (!atomic_read(&(mhi_info->read_ch.opened)) \|\|
		!atomic_read(&(mhi_info->write_ch.opened))) {
		@@ -438,7 +459,7 @@ static void mhi_read_done_work_fn(struct work_struct *work)
		spin_unlock_irqrestore(&mhi_info->read_ch.lock, flags);
		if (!buf)
		break;
		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		DIAG_LOG(DIAG_DEBUG_MHI,
		"read from mhi port %d buf %pK len:%d\n",
		mhi_info->id, buf, len);
		/*
		@@ -504,7 +525,7 @@ static void mhi_read_work_fn(struct work_struct *work)
		goto fail;
		}

		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		DIAG_LOG(DIAG_DEBUG_MHI,
		"queueing a read buf %pK, ch: %s\n",
		buf, mhi_info->name);

		@@ -553,54 +574,65 @@ static int mhi_write(int token, int ch, unsigned char *buf, int len, int ctxt)
		unsigned long flags;
		struct diag_mhi_ch_t *ch_info = NULL;
		int dev_idx = get_id_from_token(token);
		struct diag_mhi_info *mhi_info = NULL;

		if (dev_idx < 0 \|\| dev_idx >= NUM_MHI_DEV) {
		pr_err_ratelimited("diag: In %s, invalid index %d\n", __func__,
		pr_err_ratelimited("diag: %s: invalid index %d\n", __func__,
		dev_idx);
		return -EINVAL;
		}

		if (ch < 0 \|\| ch >= NUM_MHI_CHAN) {
		pr_err_ratelimited("diag: In %s, invalid chan %d\n", __func__,
		pr_err_ratelimited("diag: %s: invalid chan %d\n", __func__,
		ch);
		return -EINVAL;
		}

		if (!buf \|\| len <= 0) {
		pr_err("diag: In %s, ch %d, invalid buf %pK len %d\n",
		pr_err("diag: %s: ch: %d, invalid buf %pK len %d\n",
		__func__, dev_idx, buf, len);
		return -EINVAL;
		}

		if (!diag_mhi[dev_idx][ch].enabled) {
		pr_err_ratelimited("diag: In %s, MHI channel %s is not enabled\n",
		__func__, diag_mhi[dev_idx][ch].name);
		mhi_info = &diag_mhi[dev_idx][ch];

		if (!mhi_info) {
		pr_err_ratelimited("diag: %s, Invalid MHI info\n",
		__func__);
		return -EINVAL;
		}

		if (!mhi_info->enabled) {
		pr_err_ratelimited("diag: %s: MHI channel %s is not enabled\n",
		__func__, mhi_info->name);
		return -EIO;
		}

		ch_info = &diag_mhi[dev_idx][ch].write_ch;
		ch_info = &mhi_info->write_ch;
		if (!(atomic_read(&(ch_info->opened)))) {
		pr_err_ratelimited("diag: In %s, MHI write channel %s is not open\n",
		__func__, diag_mhi[dev_idx][ch].name);
		pr_err_ratelimited("diag: %s: MHI write channel %s is not open\n",
		__func__, mhi_info->name);
		return -EIO;
		}

		spin_lock_irqsave(&ch_info->lock, flags);
		err = mhi_buf_tbl_add(&diag_mhi[dev_idx][ch], TYPE_MHI_WRITE_CH, buf,
		err = mhi_buf_tbl_add(mhi_info, TYPE_MHI_WRITE_CH, buf,
		len);
		if (err) {
		spin_unlock_irqrestore(&ch_info->lock, flags);
		goto fail;
		}
		DIAG_LOG(DIAG_DEBUG_MHI, "diag: queueing a write buf %pK, ch: %s\n",
		buf, mhi_info->name);

		err = mhi_queue_transfer(diag_mhi[dev_idx][ch].mhi_dev, DMA_TO_DEVICE,
		err = mhi_queue_transfer(mhi_info->mhi_dev, DMA_TO_DEVICE,
		buf, len, mhi_flags);
		spin_unlock_irqrestore(&ch_info->lock, flags);
		if (err) {
		DIAG_LOG(DIAG_DEBUG_MHI,
		"diag: Cannot write to MHI channel %s, len %d, err: %d\n",
		__func__, diag_mhi[dev_idx][ch].name, len, err);
		mhi_buf_tbl_remove(&diag_mhi[dev_idx][ch], TYPE_MHI_WRITE_CH,
		"diag: Cannot write to MHI channel: %s, len %d, err: %d\n",
		mhi_info->name, len, err);
		mhi_buf_tbl_remove(mhi_info, TYPE_MHI_WRITE_CH,
		buf, len);
		goto fail;
		}
		@@ -688,7 +720,7 @@ static void diag_mhi_read_cb(struct mhi_device *mhi_dev,
		spin_lock_irqsave(&mhi_info->read_ch.lock, flags);
		tp = kmalloc(sizeof(*tp), GFP_ATOMIC);
		if (!tp) {
		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		DIAG_LOG(DIAG_DEBUG_MHI,
		"no mem for list\n");
		spin_unlock_irqrestore(&mhi_info->read_ch.lock, flags);
		return;
		@@ -697,7 +729,7 @@ static void diag_mhi_read_cb(struct mhi_device *mhi_dev,
		&mhi_info->read_ch.buf_tbl, link) {
		if (item->buf == buf) {
		DIAG_LOG(DIAG_DEBUG_MHI,
		"Callback received on buffer:%pK from mhi\n",
		"Read callback received on buffer:%pK from mhi\n",
		buf);
		tp->buf = buf;
		tp->len = result->bytes_xferd;
		@@ -737,6 +769,9 @@ static void diag_mhi_write_cb(struct mhi_device *mhi_dev,
		__func__);
		return;
		}
		DIAG_LOG(DIAG_DEBUG_MHI,
		"Write callback received on buffer:%pK from mhi\n",
		buf);
		mhi_buf_tbl_remove(mhi_info, TYPE_MHI_WRITE_CH, buf,
		result->bytes_xferd);
		diag_remote_dev_write_done(mhi_info->dev_id, buf,
		@@ -756,6 +791,11 @@ static void diag_mhi_remove(struct mhi_device *mhi_dev)
		return;
		if (!mhi_info->enabled)
		return;

		DIAG_LOG(DIAG_DEBUG_MHI,
		"Remove called on mhi channel: %s\n",
		mhi_info->name);

		__mhi_close(mhi_info, CHANNELS_CLOSED);
		spin_lock_irqsave(&mhi_info->lock, flags);
		mhi_info->enabled = 0;
		@@ -796,11 +836,11 @@ static int diag_mhi_probe(struct mhi_device *mhi_dev,
		}

		mhi_info = &diag_mhi[dev_idx][ch];
		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		DIAG_LOG(DIAG_DEBUG_MHI,
		"received probe for dev:%d ch:%d\n",
		dev_idx, ch);
		mhi_info->mhi_dev = mhi_dev;
		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		DIAG_LOG(DIAG_DEBUG_MHI,
		"diag: mhi device is ready to open\n");
		spin_lock_irqsave(&mhi_info->lock, flags);
		mhi_info->enabled = 1;
		@@ -884,7 +924,7 @@ int diag_mhi_init(void)
		ch, dev_idx, err);
		goto fail;
		}
		DIAG_LOG(DIAG_DEBUG_BRIDGE,
		DIAG_LOG(DIAG_DEBUG_MHI,
		"mhi dev %d port %d initialized\n",
		dev_idx, ch);
		}