trace.h

  1/* SPDX-License-Identifier: GPL-2.0-only */
  2/*
  3 * Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved.
  4 */
  5
  6#undef TRACE_SYSTEM
  7#define TRACE_SYSTEM mhi_host
  8
  9#if !defined(_TRACE_EVENT_MHI_HOST_H) || defined(TRACE_HEADER_MULTI_READ)
 10#define _TRACE_EVENT_MHI_HOST_H
 11
 12#include <linux/byteorder/generic.h>
 13#include <linux/tracepoint.h>
 14#include <linux/trace_seq.h>
 15#include "../common.h"
 16#include "internal.h"
 17
 18#undef mhi_state
 19#undef mhi_state_end
 20
 21#define mhi_state(a, b)		TRACE_DEFINE_ENUM(MHI_STATE_##a);
 22#define mhi_state_end(a, b)	TRACE_DEFINE_ENUM(MHI_STATE_##a);
 23
 24MHI_STATE_LIST
 25
 26#undef mhi_state
 27#undef mhi_state_end
 28
 29#define mhi_state(a, b)		{ MHI_STATE_##a, b },
 30#define mhi_state_end(a, b)	{ MHI_STATE_##a, b }
 31
 32#undef mhi_pm_state
 33#undef mhi_pm_state_end
 34
 35#define mhi_pm_state(a, b)		TRACE_DEFINE_ENUM(MHI_PM_STATE_##a);
 36#define mhi_pm_state_end(a, b)		TRACE_DEFINE_ENUM(MHI_PM_STATE_##a);
 37
 38MHI_PM_STATE_LIST
 39
 40#undef mhi_pm_state
 41#undef mhi_pm_state_end
 42
 43#define mhi_pm_state(a, b)		{ MHI_PM_STATE_##a, b },
 44#define mhi_pm_state_end(a, b)		{ MHI_PM_STATE_##a, b }
 45
 46#undef mhi_ee
 47#undef mhi_ee_end
 48
 49#define mhi_ee(a, b)			TRACE_DEFINE_ENUM(MHI_EE_##a);
 50#define mhi_ee_end(a, b)		TRACE_DEFINE_ENUM(MHI_EE_##a);
 51
 52MHI_EE_LIST
 53
 54#undef mhi_ee
 55#undef mhi_ee_end
 56
 57#define mhi_ee(a, b)			{ MHI_EE_##a, b },
 58#define mhi_ee_end(a, b)		{ MHI_EE_##a, b }
 59
 60#undef ch_state_type
 61#undef ch_state_type_end
 62
 63#define ch_state_type(a, b)		TRACE_DEFINE_ENUM(MHI_CH_STATE_TYPE_##a);
 64#define ch_state_type_end(a, b)		TRACE_DEFINE_ENUM(MHI_CH_STATE_TYPE_##a);
 65
 66MHI_CH_STATE_TYPE_LIST
 67
 68#undef ch_state_type
 69#undef ch_state_type_end
 70
 71#define ch_state_type(a, b)		{ MHI_CH_STATE_TYPE_##a, b },
 72#define ch_state_type_end(a, b)		{ MHI_CH_STATE_TYPE_##a, b }
 73
 74#undef dev_st_trans
 75#undef dev_st_trans_end
 76
 77#define dev_st_trans(a, b)		TRACE_DEFINE_ENUM(DEV_ST_TRANSITION_##a);
 78#define dev_st_trans_end(a, b)		TRACE_DEFINE_ENUM(DEV_ST_TRANSITION_##a);
 79
 80DEV_ST_TRANSITION_LIST
 81
 82#undef dev_st_trans
 83#undef dev_st_trans_end
 84
 85#define dev_st_trans(a, b)		{ DEV_ST_TRANSITION_##a, b },
 86#define dev_st_trans_end(a, b)		{ DEV_ST_TRANSITION_##a, b }
 87
 88#define TPS(x)	tracepoint_string(x)
 89
 90TRACE_EVENT(mhi_gen_tre,
 91
 92	TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan,
 93		 struct mhi_ring_element *mhi_tre),
 94
 95	TP_ARGS(mhi_cntrl, mhi_chan, mhi_tre),
 96
 97	TP_STRUCT__entry(
 98		__string(name, mhi_cntrl->mhi_dev->name)
 99		__field(int, ch_num)
100		__field(void *, wp)
101		__field(uint64_t, tre_ptr)
102		__field(uint32_t, dword0)
103		__field(uint32_t, dword1)
104	),
105
106	TP_fast_assign(
107		__assign_str(name);
108		__entry->ch_num = mhi_chan->chan;
109		__entry->wp = mhi_tre;
110		__entry->tre_ptr = le64_to_cpu(mhi_tre->ptr);
111		__entry->dword0 = le32_to_cpu(mhi_tre->dword[0]);
112		__entry->dword1 = le32_to_cpu(mhi_tre->dword[1]);
113	),
114
115	TP_printk("%s: Chan: %d TRE: 0x%p TRE buf: 0x%llx DWORD0: 0x%08x DWORD1: 0x%08x\n",
116		  __get_str(name), __entry->ch_num, __entry->wp, __entry->tre_ptr,
117		  __entry->dword0, __entry->dword1)
118);
119
120TRACE_EVENT(mhi_intvec_states,
121
122	TP_PROTO(struct mhi_controller *mhi_cntrl, int dev_ee, int dev_state),
123
124	TP_ARGS(mhi_cntrl, dev_ee, dev_state),
125
126	TP_STRUCT__entry(
127		__string(name, mhi_cntrl->mhi_dev->name)
128		__field(int, local_ee)
129		__field(int, state)
130		__field(int, dev_ee)
131		__field(int, dev_state)
132	),
133
134	TP_fast_assign(
135		__assign_str(name);
136		__entry->local_ee = mhi_cntrl->ee;
137		__entry->state = mhi_cntrl->dev_state;
138		__entry->dev_ee = dev_ee;
139		__entry->dev_state = dev_state;
140	),
141
142	TP_printk("%s: Local EE: %s State: %s Device EE: %s Dev State: %s\n",
143		  __get_str(name),
144		  __print_symbolic(__entry->local_ee, MHI_EE_LIST),
145		  __print_symbolic(__entry->state, MHI_STATE_LIST),
146		  __print_symbolic(__entry->dev_ee, MHI_EE_LIST),
147		  __print_symbolic(__entry->dev_state, MHI_STATE_LIST))
148);
149
150TRACE_EVENT(mhi_tryset_pm_state,
151
152	TP_PROTO(struct mhi_controller *mhi_cntrl, int pm_state),
153
154	TP_ARGS(mhi_cntrl, pm_state),
155
156	TP_STRUCT__entry(
157		__string(name, mhi_cntrl->mhi_dev->name)
158		__field(int, pm_state)
159	),
160
161	TP_fast_assign(
162		__assign_str(name);
163		if (pm_state)
164			pm_state = __fls(pm_state);
165		__entry->pm_state = pm_state;
166	),
167
168	TP_printk("%s: PM state: %s\n", __get_str(name),
169		  __print_symbolic(__entry->pm_state, MHI_PM_STATE_LIST))
170);
171
172DECLARE_EVENT_CLASS(mhi_process_event_ring,
173
174	TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_ring_element *rp),
175
176	TP_ARGS(mhi_cntrl, rp),
177
178	TP_STRUCT__entry(
179		__string(name, mhi_cntrl->mhi_dev->name)
180		__field(uint32_t, dword0)
181		__field(uint32_t, dword1)
182		__field(int, state)
183		__field(uint64_t, ptr)
184		__field(void *, rp)
185	),
186
187	TP_fast_assign(
188		__assign_str(name);
189		__entry->rp = rp;
190		__entry->ptr = le64_to_cpu(rp->ptr);
191		__entry->dword0 = le32_to_cpu(rp->dword[0]);
192		__entry->dword1 = le32_to_cpu(rp->dword[1]);
193		__entry->state = MHI_TRE_GET_EV_STATE(rp);
194	),
195
196	TP_printk("%s: TRE: 0x%p TRE buf: 0x%llx DWORD0: 0x%08x DWORD1: 0x%08x State: %s\n",
197		  __get_str(name), __entry->rp, __entry->ptr, __entry->dword0,
198		  __entry->dword1, __print_symbolic(__entry->state, MHI_STATE_LIST))
199);
200
201DEFINE_EVENT(mhi_process_event_ring, mhi_data_event,
202
203	TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_ring_element *rp),
204
205	TP_ARGS(mhi_cntrl, rp)
206);
207
208DEFINE_EVENT(mhi_process_event_ring, mhi_ctrl_event,
209
210	TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_ring_element *rp),
211
212	TP_ARGS(mhi_cntrl, rp)
213);
214
215DECLARE_EVENT_CLASS(mhi_update_channel_state,
216
217	TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan, int state,
218		 const char *reason),
219
220	TP_ARGS(mhi_cntrl, mhi_chan, state, reason),
221
222	TP_STRUCT__entry(
223		__string(name, mhi_cntrl->mhi_dev->name)
224		__field(int, ch_num)
225		__field(int, state)
226		__field(const char *, reason)
227	),
228
229	TP_fast_assign(
230		__assign_str(name);
231		__entry->ch_num = mhi_chan->chan;
232		__entry->state = state;
233		__entry->reason = reason;
234	),
235
236	TP_printk("%s: chan%d: %s state to: %s\n",
237		  __get_str(name),  __entry->ch_num, __entry->reason,
238		  __print_symbolic(__entry->state, MHI_CH_STATE_TYPE_LIST))
239);
240
241DEFINE_EVENT(mhi_update_channel_state, mhi_channel_command_start,
242
243	TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan, int state,
244		 const char *reason),
245
246	TP_ARGS(mhi_cntrl, mhi_chan, state, reason)
247);
248
249DEFINE_EVENT(mhi_update_channel_state, mhi_channel_command_end,
250
251	TP_PROTO(struct mhi_controller *mhi_cntrl, struct mhi_chan *mhi_chan, int state,
252		 const char *reason),
253
254	TP_ARGS(mhi_cntrl, mhi_chan, state, reason)
255);
256
257TRACE_EVENT(mhi_pm_st_transition,
258
259	TP_PROTO(struct mhi_controller *mhi_cntrl, int state),
260
261	TP_ARGS(mhi_cntrl, state),
262
263	TP_STRUCT__entry(
264		__string(name, mhi_cntrl->mhi_dev->name)
265		__field(int, state)
266	),
267
268	TP_fast_assign(
269		__assign_str(name);
270		__entry->state = state;
271	),
272
273	TP_printk("%s: Handling state transition: %s\n", __get_str(name),
274		  __print_symbolic(__entry->state, DEV_ST_TRANSITION_LIST))
275);
276
277#endif
278#undef TRACE_INCLUDE_PATH
279#define TRACE_INCLUDE_PATH ../../drivers/bus/mhi/host
280#undef TRACE_INCLUDE_FILE
281#define TRACE_INCLUDE_FILE trace
282
283#include <trace/define_trace.h>