Commit ceeb64f4 authored by Krishna chaitanya chundru's avatar Krishna chaitanya chundru Committed by Manivannan Sadhasivam
Browse files

bus: mhi: host: Add tracing support 



This change adds ftrace support for following functions which
helps in debugging the issues when there is Channel state & MHI
state change and also when we receive data and control events:
1. mhi_intvec_mhi_states
2. mhi_process_data_event_ring
3. mhi_process_ctrl_ev_ring
4. mhi_gen_tre
5. mhi_update_channel_state
6. mhi_tryset_pm_state
7. mhi_pm_st_worker

Change the implementation of the arrays which has enum to strings mapping
to make it consistent in both trace header file and other files.

Where ever the trace events are added, debug messages are removed.

Signed-off-by: default avatarKrishna chaitanya chundru <quic_krichai@quicinc.com>
Reviewed-by: default avatarManivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
Reviewed-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
Link: https://lore.kernel.org/r/20240206-ftrace_support-v11-1-3f71dc187544@quicinc.com


Signed-off-by: default avatarManivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
parent ae1d892d

drivers/bus/mhi/common.h

+19 −19
Original line number Diff line number Diff line
@@ -297,30 +297,30 @@ struct mhi_ring_element { 
	__le32 dword[2];

};



#define MHI_STATE_LIST				\

	mhi_state(RESET,	"RESET")	\

	mhi_state(READY,	"READY")	\

	mhi_state(M0,		"M0")		\

	mhi_state(M1,		"M1")		\

	mhi_state(M2,		"M2")		\

	mhi_state(M3,		"M3")		\

	mhi_state(M3_FAST,	"M3_FAST")	\

	mhi_state(BHI,		"BHI")		\

	mhi_state_end(SYS_ERR,	"SYS ERROR")



#undef mhi_state

#undef mhi_state_end



#define mhi_state(a, b)		case MHI_STATE_##a: return b;

#define mhi_state_end(a, b)	case MHI_STATE_##a: return b;



static inline const char *mhi_state_str(enum mhi_state state)

{

	switch (state) {

	case MHI_STATE_RESET:

		return "RESET";

	case MHI_STATE_READY:

		return "READY";

	case MHI_STATE_M0:

		return "M0";

	case MHI_STATE_M1:

		return "M1";

	case MHI_STATE_M2:

		return "M2";

	case MHI_STATE_M3:

		return "M3";

	case MHI_STATE_M3_FAST:

		return "M3 FAST";

	case MHI_STATE_BHI:

		return "BHI";

	case MHI_STATE_SYS_ERR:

		return "SYS ERROR";

	MHI_STATE_LIST

	default:

		return "Unknown state";

	}

};

}



#endif /* _MHI_COMMON_H */

drivers/bus/mhi/host/init.c

+31 −33
Original line number Diff line number Diff line
@@ -20,51 +20,49 @@ 
#include <linux/wait.h>

#include "internal.h"



#define CREATE_TRACE_POINTS

#include "trace.h"



static DEFINE_IDA(mhi_controller_ida);



#undef mhi_ee

#undef mhi_ee_end



#define mhi_ee(a, b)		[MHI_EE_##a] = b,

#define mhi_ee_end(a, b)	[MHI_EE_##a] = b,



const char * const mhi_ee_str[MHI_EE_MAX] = {

	[MHI_EE_PBL] = "PRIMARY BOOTLOADER",

	[MHI_EE_SBL] = "SECONDARY BOOTLOADER",

	[MHI_EE_AMSS] = "MISSION MODE",

	[MHI_EE_RDDM] = "RAMDUMP DOWNLOAD MODE",

	[MHI_EE_WFW] = "WLAN FIRMWARE",

	[MHI_EE_PTHRU] = "PASS THROUGH",

	[MHI_EE_EDL] = "EMERGENCY DOWNLOAD",

	[MHI_EE_FP] = "FLASH PROGRAMMER",

	[MHI_EE_DISABLE_TRANSITION] = "DISABLE",

	[MHI_EE_NOT_SUPPORTED] = "NOT SUPPORTED",

	MHI_EE_LIST

};



#undef dev_st_trans

#undef dev_st_trans_end



#define dev_st_trans(a, b)	[DEV_ST_TRANSITION_##a] = b,

#define dev_st_trans_end(a, b)	[DEV_ST_TRANSITION_##a] = b,



const char * const dev_state_tran_str[DEV_ST_TRANSITION_MAX] = {

	[DEV_ST_TRANSITION_PBL] = "PBL",

	[DEV_ST_TRANSITION_READY] = "READY",

	[DEV_ST_TRANSITION_SBL] = "SBL",

	[DEV_ST_TRANSITION_MISSION_MODE] = "MISSION MODE",

	[DEV_ST_TRANSITION_FP] = "FLASH PROGRAMMER",

	[DEV_ST_TRANSITION_SYS_ERR] = "SYS ERROR",

	[DEV_ST_TRANSITION_DISABLE] = "DISABLE",

	DEV_ST_TRANSITION_LIST

};



#undef ch_state_type

#undef ch_state_type_end



#define ch_state_type(a, b)	[MHI_CH_STATE_TYPE_##a] = b,

#define ch_state_type_end(a, b)	[MHI_CH_STATE_TYPE_##a] = b,



const char * const mhi_ch_state_type_str[MHI_CH_STATE_TYPE_MAX] = {

	[MHI_CH_STATE_TYPE_RESET] = "RESET",

	[MHI_CH_STATE_TYPE_STOP] = "STOP",

	[MHI_CH_STATE_TYPE_START] = "START",

	MHI_CH_STATE_TYPE_LIST

};



#undef mhi_pm_state

#undef mhi_pm_state_end



#define mhi_pm_state(a, b)	[MHI_PM_STATE_##a] = b,

#define mhi_pm_state_end(a, b)	[MHI_PM_STATE_##a] = b,



static const char * const mhi_pm_state_str[] = {

	[MHI_PM_STATE_DISABLE] = "DISABLE",

	[MHI_PM_STATE_POR] = "POWER ON RESET",

	[MHI_PM_STATE_M0] = "M0",

	[MHI_PM_STATE_M2] = "M2",

	[MHI_PM_STATE_M3_ENTER] = "M?->M3",

	[MHI_PM_STATE_M3] = "M3",

	[MHI_PM_STATE_M3_EXIT] = "M3->M0",

	[MHI_PM_STATE_FW_DL_ERR] = "Firmware Download Error",

	[MHI_PM_STATE_SYS_ERR_DETECT] = "SYS ERROR Detect",

	[MHI_PM_STATE_SYS_ERR_PROCESS] = "SYS ERROR Process",

	[MHI_PM_STATE_SYS_ERR_FAIL] = "SYS ERROR Failure",

	[MHI_PM_STATE_SHUTDOWN_PROCESS] = "SHUTDOWN Process",

	[MHI_PM_STATE_LD_ERR_FATAL_DETECT] = "Linkdown or Error Fatal Detect",

	MHI_PM_STATE_LIST

};



const char *to_mhi_pm_state_str(u32 state)

drivers/bus/mhi/host/internal.h

+41 −0
Original line number Diff line number Diff line
@@ -42,6 +42,11 @@ enum mhi_ch_state_type { 
	MHI_CH_STATE_TYPE_MAX,

};



#define MHI_CH_STATE_TYPE_LIST				\

	ch_state_type(RESET,		"RESET")	\

	ch_state_type(STOP,		"STOP")		\

	ch_state_type_end(START,	"START")



extern const char * const mhi_ch_state_type_str[MHI_CH_STATE_TYPE_MAX];

#define TO_CH_STATE_TYPE_STR(state) (((state) >= MHI_CH_STATE_TYPE_MAX) ? \

				     "INVALID_STATE" : \
@@ -50,6 +55,18 @@ extern const char * const mhi_ch_state_type_str[MHI_CH_STATE_TYPE_MAX]; 
#define MHI_INVALID_BRSTMODE(mode) (mode != MHI_DB_BRST_DISABLE && \

				    mode != MHI_DB_BRST_ENABLE)



#define MHI_EE_LIST						\

	mhi_ee(PBL,			"PRIMARY BOOTLOADER")	\

	mhi_ee(SBL,			"SECONDARY BOOTLOADER")	\

	mhi_ee(AMSS,			"MISSION MODE")		\

	mhi_ee(RDDM,			"RAMDUMP DOWNLOAD MODE")\

	mhi_ee(WFW,			"WLAN FIRMWARE")	\

	mhi_ee(PTHRU,			"PASS THROUGH")		\

	mhi_ee(EDL,			"EMERGENCY DOWNLOAD")	\

	mhi_ee(FP,			"FLASH PROGRAMMER")	\

	mhi_ee(DISABLE_TRANSITION,	"DISABLE")		\

	mhi_ee_end(NOT_SUPPORTED,	"NOT SUPPORTED")



extern const char * const mhi_ee_str[MHI_EE_MAX];

#define TO_MHI_EXEC_STR(ee) (((ee) >= MHI_EE_MAX) ? \

			     "INVALID_EE" : mhi_ee_str[ee])
@@ -72,6 +89,15 @@ enum dev_st_transition { 
	DEV_ST_TRANSITION_MAX,

};



#define DEV_ST_TRANSITION_LIST					\

	dev_st_trans(PBL,		"PBL")			\

	dev_st_trans(READY,		"READY")		\

	dev_st_trans(SBL,		"SBL")			\

	dev_st_trans(MISSION_MODE,	"MISSION MODE")		\

	dev_st_trans(FP,		"FLASH PROGRAMMER")	\

	dev_st_trans(SYS_ERR,		"SYS ERROR")		\

	dev_st_trans_end(DISABLE,	"DISABLE")



extern const char * const dev_state_tran_str[DEV_ST_TRANSITION_MAX];

#define TO_DEV_STATE_TRANS_STR(state) (((state) >= DEV_ST_TRANSITION_MAX) ? \

				"INVALID_STATE" : dev_state_tran_str[state])
@@ -94,6 +120,21 @@ enum mhi_pm_state { 
	MHI_PM_STATE_MAX

};



#define MHI_PM_STATE_LIST							\

	mhi_pm_state(DISABLE,			"DISABLE")			\

	mhi_pm_state(POR,			"POWER ON RESET")		\

	mhi_pm_state(M0,			"M0")				\

	mhi_pm_state(M2,			"M2")				\

	mhi_pm_state(M3_ENTER,			"M?->M3")			\

	mhi_pm_state(M3,			"M3")				\

	mhi_pm_state(M3_EXIT,			"M3->M0")			\

	mhi_pm_state(FW_DL_ERR,			"Firmware Download Error")	\

	mhi_pm_state(SYS_ERR_DETECT,		"SYS ERROR Detect")		\

	mhi_pm_state(SYS_ERR_PROCESS,		"SYS ERROR Process")		\

	mhi_pm_state(SYS_ERR_FAIL,		"SYS ERROR Failure")		\

	mhi_pm_state(SHUTDOWN_PROCESS,		"SHUTDOWN Process")		\

	mhi_pm_state_end(LD_ERR_FATAL_DETECT,	"Linkdown or Error Fatal Detect")



#define MHI_PM_DISABLE					BIT(0)

#define MHI_PM_POR					BIT(1)

#define MHI_PM_M0					BIT(2)

drivers/bus/mhi/host/main.c

+9 −10
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include <linux/skbuff.h>

#include <linux/slab.h>

#include "internal.h"

#include "trace.h"



int __must_check mhi_read_reg(struct mhi_controller *mhi_cntrl,

			      void __iomem *base, u32 offset, u32 *out)
@@ -493,11 +494,8 @@ irqreturn_t mhi_intvec_threaded_handler(int irq_number, void *priv) 


	state = mhi_get_mhi_state(mhi_cntrl);

	ee = mhi_get_exec_env(mhi_cntrl);

	dev_dbg(dev, "local ee: %s state: %s device ee: %s state: %s\n",

		TO_MHI_EXEC_STR(mhi_cntrl->ee),

		mhi_state_str(mhi_cntrl->dev_state),

		TO_MHI_EXEC_STR(ee), mhi_state_str(state));



	trace_mhi_intvec_states(mhi_cntrl, ee, state);

	if (state == MHI_STATE_SYS_ERR) {

		dev_dbg(dev, "System error detected\n");

		pm_state = mhi_tryset_pm_state(mhi_cntrl,
@@ -838,6 +836,8 @@ int mhi_process_ctrl_ev_ring(struct mhi_controller *mhi_cntrl, 
	while (dev_rp != local_rp) {

		enum mhi_pkt_type type = MHI_TRE_GET_EV_TYPE(local_rp);



		trace_mhi_ctrl_event(mhi_cntrl, local_rp);



		switch (type) {

		case MHI_PKT_TYPE_BW_REQ_EVENT:

		{
@@ -1003,6 +1003,8 @@ int mhi_process_data_event_ring(struct mhi_controller *mhi_cntrl, 
	while (dev_rp != local_rp && event_quota > 0) {

		enum mhi_pkt_type type = MHI_TRE_GET_EV_TYPE(local_rp);



		trace_mhi_data_event(mhi_cntrl, local_rp);



		chan = MHI_TRE_GET_EV_CHID(local_rp);



		WARN_ON(chan >= mhi_cntrl->max_chan);
@@ -1243,6 +1245,7 @@ int mhi_gen_tre(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan, 
	mhi_tre->dword[0] = MHI_TRE_DATA_DWORD0(info->len);

	mhi_tre->dword[1] = MHI_TRE_DATA_DWORD1(bei, eot, eob, chain);



	trace_mhi_gen_tre(mhi_cntrl, mhi_chan, mhi_tre);

	/* increment WP */

	mhi_add_ring_element(mhi_cntrl, tre_ring);

	mhi_add_ring_element(mhi_cntrl, buf_ring);
@@ -1337,9 +1340,7 @@ static int mhi_update_channel_state(struct mhi_controller *mhi_cntrl, 
	enum mhi_cmd_type cmd = MHI_CMD_NOP;

	int ret;



	dev_dbg(dev, "%d: Updating channel state to: %s\n", mhi_chan->chan,

		TO_CH_STATE_TYPE_STR(to_state));



	trace_mhi_channel_command_start(mhi_cntrl, mhi_chan, to_state, "Updating");

	switch (to_state) {

	case MHI_CH_STATE_TYPE_RESET:

		write_lock_irq(&mhi_chan->lock);
@@ -1406,9 +1407,7 @@ static int mhi_update_channel_state(struct mhi_controller *mhi_cntrl, 
		write_unlock_irq(&mhi_chan->lock);

	}



	dev_dbg(dev, "%d: Channel state change to %s successful\n",

		mhi_chan->chan, TO_CH_STATE_TYPE_STR(to_state));



	trace_mhi_channel_command_end(mhi_cntrl, mhi_chan, to_state, "Updated");

exit_channel_update:

	mhi_cntrl->runtime_put(mhi_cntrl);

	mhi_device_put(mhi_cntrl->mhi_dev);

drivers/bus/mhi/host/pm.c

+4 −3
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include <linux/slab.h>

#include <linux/wait.h>

#include "internal.h"

#include "trace.h"



/*

 * Not all MHI state transitions are synchronous. Transitions like Linkdown,
@@ -131,6 +132,7 @@ enum mhi_pm_state __must_check mhi_tryset_pm_state(struct mhi_controller *mhi_cn 
	if (unlikely(!(dev_state_transitions[index].to_states & state)))

		return cur_state;



	trace_mhi_tryset_pm_state(mhi_cntrl, state);

	mhi_cntrl->pm_state = state;

	return mhi_cntrl->pm_state;

}
@@ -772,7 +774,6 @@ void mhi_pm_st_worker(struct work_struct *work) 
	struct mhi_controller *mhi_cntrl = container_of(work,

							struct mhi_controller,

							st_worker);

	struct device *dev = &mhi_cntrl->mhi_dev->dev;



	spin_lock_irq(&mhi_cntrl->transition_lock);

	list_splice_tail_init(&mhi_cntrl->transition_list, &head);
@@ -780,8 +781,8 @@ void mhi_pm_st_worker(struct work_struct *work) 


	list_for_each_entry_safe(itr, tmp, &head, node) {

		list_del(&itr->node);

		dev_dbg(dev, "Handling state transition: %s\n",

			TO_DEV_STATE_TRANS_STR(itr->state));



		trace_mhi_pm_st_transition(mhi_cntrl, itr->state);



		switch (itr->state) {

		case DEV_ST_TRANSITION_PBL: