[thirdparty/kernel/stable.git] / drivers / net / wireless / ath / ath10k / trace.h

/* SPDX-License-Identifier: ISC */
/*
 * Copyright (c) 2005-2011 Atheros Communications Inc.
 * Copyright (c) 2011-2016 Qualcomm Atheros, Inc.
 */

#if !defined(_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)

#include <linux/tracepoint.h>
#include "core.h"

#if !defined(_TRACE_H_)
static inline u32 ath10k_frm_hdr_len(const void *buf, size_t len)
{
	const struct ieee80211_hdr *hdr = buf;

	/* In some rare cases (e.g. fcs error) device reports frame buffer
	 * shorter than what frame header implies (e.g. len = 0). The buffer
	 * can still be accessed so do a simple min() to guarantee caller
	 * doesn't get value greater than len.
	 */
	return min_t(u32, len, ieee80211_hdrlen(hdr->frame_control));
}
#endif

#define _TRACE_H_

/* create empty functions when tracing is disabled */
#if !defined(CONFIG_ATH10K_TRACING)
#undef TRACE_EVENT
#define TRACE_EVENT(name, proto, ...) \
static inline void trace_ ## name(proto) {} \
static inline bool trace_##name##_enabled(void) \
{						\
	return false;				\
}
#undef DECLARE_EVENT_CLASS
#define DECLARE_EVENT_CLASS(...)
#undef DEFINE_EVENT
#define DEFINE_EVENT(evt_class, name, proto, ...) \
static inline void trace_ ## name(proto) {}
#endif /* !CONFIG_ATH10K_TRACING || __CHECKER__ */

#undef TRACE_SYSTEM
#define TRACE_SYSTEM ath10k

#define ATH10K_MSG_MAX 400

DECLARE_EVENT_CLASS(ath10k_log_event,
	TP_PROTO(struct ath10k *ar, struct va_format *vaf),
	TP_ARGS(ar, vaf),
	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__vstring(msg, vaf->fmt, vaf->va)
	),
	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__assign_vstr(msg, vaf->fmt, vaf->va);
	),
	TP_printk(
		"%s %s %s",
		__get_str(driver),
		__get_str(device),
		__get_str(msg)
	)
);

DEFINE_EVENT(ath10k_log_event, ath10k_log_err,
	     TP_PROTO(struct ath10k *ar, struct va_format *vaf),
	     TP_ARGS(ar, vaf)
);

DEFINE_EVENT(ath10k_log_event, ath10k_log_warn,
	     TP_PROTO(struct ath10k *ar, struct va_format *vaf),
	     TP_ARGS(ar, vaf)
);

DEFINE_EVENT(ath10k_log_event, ath10k_log_info,
	     TP_PROTO(struct ath10k *ar, struct va_format *vaf),
	     TP_ARGS(ar, vaf)
);

TRACE_EVENT(ath10k_log_dbg,
	TP_PROTO(struct ath10k *ar, unsigned int level, struct va_format *vaf),
	TP_ARGS(ar, level, vaf),
	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(unsigned int, level)
		__vstring(msg, vaf->fmt, vaf->va)
	),
	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->level = level;
		__assign_vstr(msg, vaf->fmt, vaf->va);
	),
	TP_printk(
		"%s %s %s",
		__get_str(driver),
		__get_str(device),
		__get_str(msg)
	)
);

TRACE_EVENT(ath10k_log_dbg_dump,
	TP_PROTO(struct ath10k *ar, const char *msg, const char *prefix,
		 const void *buf, size_t buf_len),

	TP_ARGS(ar, msg, prefix, buf, buf_len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__string(msg, msg)
		__string(prefix, prefix)
		__field(size_t, buf_len)
		__dynamic_array(u8, buf, buf_len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__assign_str(msg);
		__assign_str(prefix);
		__entry->buf_len = buf_len;
		memcpy(__get_dynamic_array(buf), buf, buf_len);
	),

	TP_printk(
		"%s %s %s/%s\n",
		__get_str(driver),
		__get_str(device),
		__get_str(prefix),
		__get_str(msg)
	)
);

TRACE_EVENT(ath10k_wmi_cmd,
	TP_PROTO(struct ath10k *ar, int id, const void *buf, size_t buf_len),

	TP_ARGS(ar, id, buf, buf_len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(unsigned int, id)
		__field(size_t, buf_len)
		__dynamic_array(u8, buf, buf_len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->id = id;
		__entry->buf_len = buf_len;
		memcpy(__get_dynamic_array(buf), buf, buf_len);
	),

	TP_printk(
		"%s %s id %d len %zu",
		__get_str(driver),
		__get_str(device),
		__entry->id,
		__entry->buf_len
	)
);

TRACE_EVENT(ath10k_wmi_event,
	TP_PROTO(struct ath10k *ar, int id, const void *buf, size_t buf_len),

	TP_ARGS(ar, id, buf, buf_len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(unsigned int, id)
		__field(size_t, buf_len)
		__dynamic_array(u8, buf, buf_len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->id = id;
		__entry->buf_len = buf_len;
		memcpy(__get_dynamic_array(buf), buf, buf_len);
	),

	TP_printk(
		"%s %s id %d len %zu",
		__get_str(driver),
		__get_str(device),
		__entry->id,
		__entry->buf_len
	)
);

TRACE_EVENT(ath10k_htt_stats,
	TP_PROTO(struct ath10k *ar, const void *buf, size_t buf_len),

	TP_ARGS(ar, buf, buf_len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(size_t, buf_len)
		__dynamic_array(u8, buf, buf_len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->buf_len = buf_len;
		memcpy(__get_dynamic_array(buf), buf, buf_len);
	),

	TP_printk(
		"%s %s len %zu",
		__get_str(driver),
		__get_str(device),
		__entry->buf_len
	)
);

TRACE_EVENT(ath10k_wmi_dbglog,
	TP_PROTO(struct ath10k *ar, const void *buf, size_t buf_len),

	TP_ARGS(ar, buf, buf_len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(u8, hw_type)
		__field(size_t, buf_len)
		__dynamic_array(u8, buf, buf_len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->hw_type = ar->hw_rev;
		__entry->buf_len = buf_len;
		memcpy(__get_dynamic_array(buf), buf, buf_len);
	),

	TP_printk(
		"%s %s %d len %zu",
		__get_str(driver),
		__get_str(device),
		__entry->hw_type,
		__entry->buf_len
	)
);

TRACE_EVENT(ath10k_htt_pktlog,
	    TP_PROTO(struct ath10k *ar, const void *buf, u16 buf_len),

	TP_ARGS(ar, buf, buf_len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(u8, hw_type)
		__field(u16, buf_len)
		__dynamic_array(u8, pktlog, buf_len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->hw_type = ar->hw_rev;
		__entry->buf_len = buf_len;
		memcpy(__get_dynamic_array(pktlog), buf, buf_len);
	),

	TP_printk(
		"%s %s %d size %u",
		__get_str(driver),
		__get_str(device),
		__entry->hw_type,
		__entry->buf_len
	 )
);

TRACE_EVENT(ath10k_htt_tx,
	    TP_PROTO(struct ath10k *ar, u16 msdu_id, u16 msdu_len,
		     u8 vdev_id, u8 tid),

	TP_ARGS(ar, msdu_id, msdu_len, vdev_id, tid),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(u16, msdu_id)
		__field(u16, msdu_len)
		__field(u8, vdev_id)
		__field(u8, tid)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->msdu_id = msdu_id;
		__entry->msdu_len = msdu_len;
		__entry->vdev_id = vdev_id;
		__entry->tid = tid;
	),

	TP_printk(
		"%s %s msdu_id %d msdu_len %d vdev_id %d tid %d",
		__get_str(driver),
		__get_str(device),
		__entry->msdu_id,
		__entry->msdu_len,
		__entry->vdev_id,
		__entry->tid
	 )
);

TRACE_EVENT(ath10k_txrx_tx_unref,
	    TP_PROTO(struct ath10k *ar, u16 msdu_id),

	TP_ARGS(ar, msdu_id),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(u16, msdu_id)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->msdu_id = msdu_id;
	),

	TP_printk(
		"%s %s msdu_id %d",
		__get_str(driver),
		__get_str(device),
		__entry->msdu_id
	 )
);

DECLARE_EVENT_CLASS(ath10k_hdr_event,
		    TP_PROTO(struct ath10k *ar, const void *data, size_t len),

	TP_ARGS(ar, data, len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(size_t, len)
		__dynamic_array(u8, data, ath10k_frm_hdr_len(data, len))
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->len = ath10k_frm_hdr_len(data, len);
		memcpy(__get_dynamic_array(data), data, __entry->len);
	),

	TP_printk(
		"%s %s len %zu\n",
		__get_str(driver),
		__get_str(device),
		__entry->len
	)
);

DECLARE_EVENT_CLASS(ath10k_payload_event,
		    TP_PROTO(struct ath10k *ar, const void *data, size_t len),

	TP_ARGS(ar, data, len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(size_t, len)
		__dynamic_array(u8, payload, (len -
					      ath10k_frm_hdr_len(data, len)))
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->len = len - ath10k_frm_hdr_len(data, len);
		memcpy(__get_dynamic_array(payload),
		       data + ath10k_frm_hdr_len(data, len), __entry->len);
	),

	TP_printk(
		"%s %s len %zu\n",
		__get_str(driver),
		__get_str(device),
		__entry->len
	)
);

DEFINE_EVENT(ath10k_hdr_event, ath10k_tx_hdr,
	     TP_PROTO(struct ath10k *ar, const void *data, size_t len),
	     TP_ARGS(ar, data, len)
);

DEFINE_EVENT(ath10k_payload_event, ath10k_tx_payload,
	     TP_PROTO(struct ath10k *ar, const void *data, size_t len),
	     TP_ARGS(ar, data, len)
);

DEFINE_EVENT(ath10k_hdr_event, ath10k_rx_hdr,
	     TP_PROTO(struct ath10k *ar, const void *data, size_t len),
	     TP_ARGS(ar, data, len)
);

DEFINE_EVENT(ath10k_payload_event, ath10k_rx_payload,
	     TP_PROTO(struct ath10k *ar, const void *data, size_t len),
	     TP_ARGS(ar, data, len)
);

TRACE_EVENT(ath10k_htt_rx_desc,
	    TP_PROTO(struct ath10k *ar, const void *data, size_t len),

	TP_ARGS(ar, data, len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(u8, hw_type)
		__field(u16, len)
		__dynamic_array(u8, rxdesc, len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->hw_type = ar->hw_rev;
		__entry->len = len;
		memcpy(__get_dynamic_array(rxdesc), data, len);
	),

	TP_printk(
		"%s %s %d rxdesc len %d",
		__get_str(driver),
		__get_str(device),
		__entry->hw_type,
		__entry->len
	 )
);

TRACE_EVENT(ath10k_wmi_diag_container,
	    TP_PROTO(struct ath10k *ar,
		     u8 type,
		     u32 timestamp,
		     u32 code,
		     u16 len,
		     const void *data),

	TP_ARGS(ar, type, timestamp, code, len, data),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(u8, type)
		__field(u32, timestamp)
		__field(u32, code)
		__field(u16, len)
		__dynamic_array(u8, data, len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->type = type;
		__entry->timestamp = timestamp;
		__entry->code = code;
		__entry->len = len;
		memcpy(__get_dynamic_array(data), data, len);
	),

	TP_printk(
		"%s %s diag container type %u timestamp %u code %u len %d",
		__get_str(driver),
		__get_str(device),
		__entry->type,
		__entry->timestamp,
		__entry->code,
		__entry->len
	)
);

TRACE_EVENT(ath10k_wmi_diag,
	    TP_PROTO(struct ath10k *ar, const void *data, size_t len),

	TP_ARGS(ar, data, len),

	TP_STRUCT__entry(
		__string(device, dev_name(ar->dev))
		__string(driver, dev_driver_string(ar->dev))
		__field(u16, len)
		__dynamic_array(u8, data, len)
	),

	TP_fast_assign(
		__assign_str(device);
		__assign_str(driver);
		__entry->len = len;
		memcpy(__get_dynamic_array(data), data, len);
	),

	TP_printk(
		"%s %s tlv diag len %d",
		__get_str(driver),
		__get_str(device),
		__entry->len
	)
);

#endif /* _TRACE_H_ || TRACE_HEADER_MULTI_READ*/

/* we don't want to use include/trace/events */
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .
#undef TRACE_INCLUDE_FILE
#define TRACE_INCLUDE_FILE trace

/* This part must be outside protection */
#include <trace/define_trace.h>
Commit	Line	Data
f0553ca9	1	/* SPDX-License-Identifier: ISC */
5e3dd157 KV	2	/*
5e3dd157 KV	3	* Copyright (c) 2005-2011 Atheros Communications Inc.
8b1083d6	4	* Copyright (c) 2011-2016 Qualcomm Atheros, Inc.
5e3dd157 KV	5	*/
	6
	7	#if !defined(_TRACE_H_) \|\| defined(TRACE_HEADER_MULTI_READ)
	8
	9	#include <linux/tracepoint.h>
d35a6c18	10	#include "core.h"
5e3dd157	11
5ce8e7fd	12	#if !defined(_TRACE_H_)
36d8230b	13	static inline u32 ath10k_frm_hdr_len(const void *buf, size_t len)
5ce8e7fd	14	{
b22a8f49 MK	15	const struct ieee80211_hdr *hdr = buf;
b22a8f49 MK	16
36d8230b MK	17	/* In some rare cases (e.g. fcs error) device reports frame buffer
	18	* shorter than what frame header implies (e.g. len = 0). The buffer
	19	* can still be accessed so do a simple min() to guarantee caller
	20	* doesn't get value greater than len.
	21	*/
	22	return min_t(u32, len, ieee80211_hdrlen(hdr->frame_control));
5ce8e7fd RM	23	}
	24	#endif
	25
5e3dd157 KV	26	#define _TRACE_H_
	27
	28	/* create empty functions when tracing is disabled */
	29	#if !defined(CONFIG_ATH10K_TRACING)
	30	#undef TRACE_EVENT
	31	#define TRACE_EVENT(name, proto, ...) \
9d740d63 VN	32	static inline void trace_ ## name(proto) {} \
	33	static inline bool trace_##name##_enabled(void) \
	34	{ \
	35	return false; \
	36	}
5e3dd157 KV	37	#undef DECLARE_EVENT_CLASS
	38	#define DECLARE_EVENT_CLASS(...)
	39	#undef DEFINE_EVENT
	40	#define DEFINE_EVENT(evt_class, name, proto, ...) \
	41	static inline void trace_ ## name(proto) {}
	42	#endif /* !CONFIG_ATH10K_TRACING \|\| __CHECKER__ */
	43
	44	#undef TRACE_SYSTEM
	45	#define TRACE_SYSTEM ath10k
	46
f42f8eb2	47	#define ATH10K_MSG_MAX 400
5e3dd157 KV	48
5e3dd157 KV	49	DECLARE_EVENT_CLASS(ath10k_log_event,
d35a6c18 MK	50	TP_PROTO(struct ath10k ar, struct va_format vaf),
d35a6c18 MK	51	TP_ARGS(ar, vaf),
5e3dd157	52	TP_STRUCT__entry(
d35a6c18 MK	53	__string(device, dev_name(ar->dev))
d35a6c18 MK	54	__string(driver, dev_driver_string(ar->dev))
c01406f8	55	__vstring(msg, vaf->fmt, vaf->va)
5e3dd157 KV	56	),
5e3dd157 KV	57	TP_fast_assign(
2c92ca84 SRG	58	__assign_str(device);
2c92ca84 SRG	59	__assign_str(driver);
c01406f8	60	__assign_vstr(msg, vaf->fmt, vaf->va);
5e3dd157	61	),
d35a6c18 MK	62	TP_printk(
	63	"%s %s %s",
	64	__get_str(driver),
	65	__get_str(device),
	66	__get_str(msg)
	67	)
5e3dd157 KV	68	);
	69
	70	DEFINE_EVENT(ath10k_log_event, ath10k_log_err,
d35a6c18 MK	71	TP_PROTO(struct ath10k ar, struct va_format vaf),
d35a6c18 MK	72	TP_ARGS(ar, vaf)
5e3dd157 KV	73	);
	74
	75	DEFINE_EVENT(ath10k_log_event, ath10k_log_warn,
d35a6c18 MK	76	TP_PROTO(struct ath10k ar, struct va_format vaf),
d35a6c18 MK	77	TP_ARGS(ar, vaf)
5e3dd157 KV	78	);
	79
	80	DEFINE_EVENT(ath10k_log_event, ath10k_log_info,
d35a6c18 MK	81	TP_PROTO(struct ath10k ar, struct va_format vaf),
d35a6c18 MK	82	TP_ARGS(ar, vaf)
5e3dd157 KV	83	);
	84
	85	TRACE_EVENT(ath10k_log_dbg,
d35a6c18 MK	86	TP_PROTO(struct ath10k ar, unsigned int level, struct va_format vaf),
d35a6c18 MK	87	TP_ARGS(ar, level, vaf),
5e3dd157	88	TP_STRUCT__entry(
d35a6c18 MK	89	__string(device, dev_name(ar->dev))
d35a6c18 MK	90	__string(driver, dev_driver_string(ar->dev))
5e3dd157	91	__field(unsigned int, level)
c01406f8	92	__vstring(msg, vaf->fmt, vaf->va)
5e3dd157 KV	93	),
5e3dd157 KV	94	TP_fast_assign(
2c92ca84 SRG	95	__assign_str(device);
2c92ca84 SRG	96	__assign_str(driver);
5e3dd157	97	__entry->level = level;
c01406f8	98	__assign_vstr(msg, vaf->fmt, vaf->va);
5e3dd157	99	),
d35a6c18 MK	100	TP_printk(
	101	"%s %s %s",
	102	__get_str(driver),
	103	__get_str(device),
	104	__get_str(msg)
	105	)
5e3dd157 KV	106	);
	107
	108	TRACE_EVENT(ath10k_log_dbg_dump,
d35a6c18	109	TP_PROTO(struct ath10k ar, const char msg, const char *prefix,
5e3dd157 KV	110	const void *buf, size_t buf_len),
5e3dd157 KV	111
d35a6c18	112	TP_ARGS(ar, msg, prefix, buf, buf_len),
5e3dd157 KV	113
5e3dd157 KV	114	TP_STRUCT__entry(
d35a6c18 MK	115	__string(device, dev_name(ar->dev))
d35a6c18 MK	116	__string(driver, dev_driver_string(ar->dev))
5e3dd157 KV	117	__string(msg, msg)
	118	__string(prefix, prefix)
	119	__field(size_t, buf_len)
	120	__dynamic_array(u8, buf, buf_len)
	121	),
	122
	123	TP_fast_assign(
2c92ca84 SRG	124	__assign_str(device);
	125	__assign_str(driver);
	126	__assign_str(msg);
	127	__assign_str(prefix);
5e3dd157 KV	128	__entry->buf_len = buf_len;
	129	memcpy(__get_dynamic_array(buf), buf, buf_len);
	130	),
	131
	132	TP_printk(
d35a6c18 MK	133	"%s %s %s/%s\n",
	134	__get_str(driver),
	135	__get_str(device),
	136	__get_str(prefix),
	137	__get_str(msg)
5e3dd157 KV	138	)
	139	);
	140
	141	TRACE_EVENT(ath10k_wmi_cmd,
9ef0f58e	142	TP_PROTO(struct ath10k ar, int id, const void buf, size_t buf_len),
5e3dd157	143
9ef0f58e	144	TP_ARGS(ar, id, buf, buf_len),
5e3dd157 KV	145
5e3dd157 KV	146	TP_STRUCT__entry(
d35a6c18 MK	147	__string(device, dev_name(ar->dev))
d35a6c18 MK	148	__string(driver, dev_driver_string(ar->dev))
5e3dd157 KV	149	__field(unsigned int, id)
	150	__field(size_t, buf_len)
	151	__dynamic_array(u8, buf, buf_len)
	152	),
	153
	154	TP_fast_assign(
2c92ca84 SRG	155	__assign_str(device);
2c92ca84 SRG	156	__assign_str(driver);
5e3dd157 KV	157	__entry->id = id;
	158	__entry->buf_len = buf_len;
	159	memcpy(__get_dynamic_array(buf), buf, buf_len);
	160	),
	161
	162	TP_printk(
9ef0f58e	163	"%s %s id %d len %zu",
d35a6c18 MK	164	__get_str(driver),
d35a6c18 MK	165	__get_str(device),
5e3dd157	166	__entry->id,
9ef0f58e	167	__entry->buf_len
5e3dd157 KV	168	)
	169	);
	170
	171	TRACE_EVENT(ath10k_wmi_event,
b22a8f49	172	TP_PROTO(struct ath10k ar, int id, const void buf, size_t buf_len),
5e3dd157	173
d35a6c18	174	TP_ARGS(ar, id, buf, buf_len),
5e3dd157 KV	175
5e3dd157 KV	176	TP_STRUCT__entry(
d35a6c18 MK	177	__string(device, dev_name(ar->dev))
d35a6c18 MK	178	__string(driver, dev_driver_string(ar->dev))
5e3dd157 KV	179	__field(unsigned int, id)
	180	__field(size_t, buf_len)
	181	__dynamic_array(u8, buf, buf_len)
	182	),
	183
	184	TP_fast_assign(
2c92ca84 SRG	185	__assign_str(device);
2c92ca84 SRG	186	__assign_str(driver);
5e3dd157 KV	187	__entry->id = id;
	188	__entry->buf_len = buf_len;
	189	memcpy(__get_dynamic_array(buf), buf, buf_len);
	190	),
	191
	192	TP_printk(
d35a6c18 MK	193	"%s %s id %d len %zu",
	194	__get_str(driver),
	195	__get_str(device),
5e3dd157 KV	196	__entry->id,
	197	__entry->buf_len
	198	)
	199	);
	200
a9bf0506	201	TRACE_EVENT(ath10k_htt_stats,
b22a8f49	202	TP_PROTO(struct ath10k ar, const void buf, size_t buf_len),
a9bf0506	203
d35a6c18	204	TP_ARGS(ar, buf, buf_len),
a9bf0506 KV	205
a9bf0506 KV	206	TP_STRUCT__entry(
d35a6c18 MK	207	__string(device, dev_name(ar->dev))
d35a6c18 MK	208	__string(driver, dev_driver_string(ar->dev))
a9bf0506 KV	209	__field(size_t, buf_len)
	210	__dynamic_array(u8, buf, buf_len)
	211	),
	212
	213	TP_fast_assign(
2c92ca84 SRG	214	__assign_str(device);
2c92ca84 SRG	215	__assign_str(driver);
a9bf0506 KV	216	__entry->buf_len = buf_len;
	217	memcpy(__get_dynamic_array(buf), buf, buf_len);
	218	),
	219
	220	TP_printk(
d35a6c18 MK	221	"%s %s len %zu",
	222	__get_str(driver),
	223	__get_str(device),
a9bf0506 KV	224	__entry->buf_len
	225	)
	226	);
	227
869526b9	228	TRACE_EVENT(ath10k_wmi_dbglog,
b22a8f49	229	TP_PROTO(struct ath10k ar, const void buf, size_t buf_len),
869526b9	230
d35a6c18	231	TP_ARGS(ar, buf, buf_len),
869526b9 KV	232
869526b9 KV	233	TP_STRUCT__entry(
d35a6c18 MK	234	__string(device, dev_name(ar->dev))
d35a6c18 MK	235	__string(driver, dev_driver_string(ar->dev))
04ae87a5	236	__field(u8, hw_type)
869526b9 KV	237	__field(size_t, buf_len)
	238	__dynamic_array(u8, buf, buf_len)
	239	),
	240
	241	TP_fast_assign(
2c92ca84 SRG	242	__assign_str(device);
2c92ca84 SRG	243	__assign_str(driver);
18353749	244	__entry->hw_type = ar->hw_rev;
869526b9 KV	245	__entry->buf_len = buf_len;
	246	memcpy(__get_dynamic_array(buf), buf, buf_len);
	247	),
	248
	249	TP_printk(
18353749	250	"%s %s %d len %zu",
d35a6c18 MK	251	__get_str(driver),
d35a6c18 MK	252	__get_str(device),
18353749	253	__entry->hw_type,
869526b9 KV	254	__entry->buf_len
	255	)
	256	);
	257
bfdd7937	258	TRACE_EVENT(ath10k_htt_pktlog,
b22a8f49	259	TP_PROTO(struct ath10k ar, const void buf, u16 buf_len),
bfdd7937 RM	260
	261	TP_ARGS(ar, buf, buf_len),
	262
	263	TP_STRUCT__entry(
	264	__string(device, dev_name(ar->dev))
	265	__string(driver, dev_driver_string(ar->dev))
04ae87a5	266	__field(u8, hw_type)
bfdd7937 RM	267	__field(u16, buf_len)
	268	__dynamic_array(u8, pktlog, buf_len)
	269	),
	270
	271	TP_fast_assign(
2c92ca84 SRG	272	__assign_str(device);
2c92ca84 SRG	273	__assign_str(driver);
18353749	274	__entry->hw_type = ar->hw_rev;
bfdd7937 RM	275	__entry->buf_len = buf_len;
	276	memcpy(__get_dynamic_array(pktlog), buf, buf_len);
	277	),
	278
	279	TP_printk(
779750bb	280	"%s %s %d size %u",
bfdd7937 RM	281	__get_str(driver),
bfdd7937 RM	282	__get_str(device),
18353749	283	__entry->hw_type,
bfdd7937 RM	284	__entry->buf_len
	285	)
	286	);
	287
d1e50f47 RM	288	TRACE_EVENT(ath10k_htt_tx,
	289	TP_PROTO(struct ath10k *ar, u16 msdu_id, u16 msdu_len,
	290	u8 vdev_id, u8 tid),
	291
	292	TP_ARGS(ar, msdu_id, msdu_len, vdev_id, tid),
	293
	294	TP_STRUCT__entry(
	295	__string(device, dev_name(ar->dev))
	296	__string(driver, dev_driver_string(ar->dev))
	297	__field(u16, msdu_id)
	298	__field(u16, msdu_len)
	299	__field(u8, vdev_id)
	300	__field(u8, tid)
	301	),
	302
	303	TP_fast_assign(
2c92ca84 SRG	304	__assign_str(device);
2c92ca84 SRG	305	__assign_str(driver);
d1e50f47 RM	306	__entry->msdu_id = msdu_id;
	307	__entry->msdu_len = msdu_len;
	308	__entry->vdev_id = vdev_id;
	309	__entry->tid = tid;
	310	),
	311
	312	TP_printk(
	313	"%s %s msdu_id %d msdu_len %d vdev_id %d tid %d",
	314	__get_str(driver),
	315	__get_str(device),
	316	__entry->msdu_id,
	317	__entry->msdu_len,
	318	__entry->vdev_id,
	319	__entry->tid
	320	)
	321	);
	322
	323	TRACE_EVENT(ath10k_txrx_tx_unref,
	324	TP_PROTO(struct ath10k *ar, u16 msdu_id),
	325
	326	TP_ARGS(ar, msdu_id),
	327
	328	TP_STRUCT__entry(
	329	__string(device, dev_name(ar->dev))
	330	__string(driver, dev_driver_string(ar->dev))
	331	__field(u16, msdu_id)
	332	),
	333
	334	TP_fast_assign(
2c92ca84 SRG	335	__assign_str(device);
2c92ca84 SRG	336	__assign_str(driver);
d1e50f47 RM	337	__entry->msdu_id = msdu_id;
	338	),
	339
	340	TP_printk(
	341	"%s %s msdu_id %d",
	342	__get_str(driver),
	343	__get_str(device),
	344	__entry->msdu_id
	345	)
	346	);
9b57f88f	347
5ce8e7fd	348	DECLARE_EVENT_CLASS(ath10k_hdr_event,
b22a8f49	349	TP_PROTO(struct ath10k ar, const void data, size_t len),
9b57f88f RM	350
	351	TP_ARGS(ar, data, len),
	352
	353	TP_STRUCT__entry(
	354	__string(device, dev_name(ar->dev))
	355	__string(driver, dev_driver_string(ar->dev))
	356	__field(size_t, len)
36d8230b	357	__dynamic_array(u8, data, ath10k_frm_hdr_len(data, len))
9b57f88f RM	358	),
	359
	360	TP_fast_assign(
2c92ca84 SRG	361	__assign_str(device);
2c92ca84 SRG	362	__assign_str(driver);
36d8230b	363	__entry->len = ath10k_frm_hdr_len(data, len);
5ce8e7fd	364	memcpy(__get_dynamic_array(data), data, __entry->len);
9b57f88f RM	365	),
	366
	367	TP_printk(
	368	"%s %s len %zu\n",
	369	__get_str(driver),
	370	__get_str(device),
	371	__entry->len
	372	)
	373	);
	374
5ce8e7fd	375	DECLARE_EVENT_CLASS(ath10k_payload_event,
b22a8f49	376	TP_PROTO(struct ath10k ar, const void data, size_t len),
5ce8e7fd RM	377
	378	TP_ARGS(ar, data, len),
	379
	380	TP_STRUCT__entry(
	381	__string(device, dev_name(ar->dev))
	382	__string(driver, dev_driver_string(ar->dev))
	383	__field(size_t, len)
36d8230b MK	384	__dynamic_array(u8, payload, (len -
36d8230b MK	385	ath10k_frm_hdr_len(data, len)))
5ce8e7fd RM	386	),
	387
	388	TP_fast_assign(
2c92ca84 SRG	389	__assign_str(device);
2c92ca84 SRG	390	__assign_str(driver);
36d8230b	391	__entry->len = len - ath10k_frm_hdr_len(data, len);
5ce8e7fd	392	memcpy(__get_dynamic_array(payload),
36d8230b	393	data + ath10k_frm_hdr_len(data, len), __entry->len);
5ce8e7fd RM	394	),
	395
	396	TP_printk(
	397	"%s %s len %zu\n",
	398	__get_str(driver),
	399	__get_str(device),
	400	__entry->len
	401	)
9b57f88f RM	402	);
9b57f88f RM	403
5ce8e7fd	404	DEFINE_EVENT(ath10k_hdr_event, ath10k_tx_hdr,
b22a8f49	405	TP_PROTO(struct ath10k ar, const void data, size_t len),
9b57f88f RM	406	TP_ARGS(ar, data, len)
	407	);
	408
5ce8e7fd	409	DEFINE_EVENT(ath10k_payload_event, ath10k_tx_payload,
b22a8f49	410	TP_PROTO(struct ath10k ar, const void data, size_t len),
9b57f88f RM	411	TP_ARGS(ar, data, len)
	412	);
	413
5ce8e7fd	414	DEFINE_EVENT(ath10k_hdr_event, ath10k_rx_hdr,
b22a8f49	415	TP_PROTO(struct ath10k ar, const void data, size_t len),
9b57f88f RM	416	TP_ARGS(ar, data, len)
9b57f88f RM	417	);
a5d85f60	418
5ce8e7fd	419	DEFINE_EVENT(ath10k_payload_event, ath10k_rx_payload,
b22a8f49	420	TP_PROTO(struct ath10k ar, const void data, size_t len),
a5d85f60 MK	421	TP_ARGS(ar, data, len)
a5d85f60 MK	422	);
5ce8e7fd RM	423
5ce8e7fd RM	424	TRACE_EVENT(ath10k_htt_rx_desc,
b22a8f49	425	TP_PROTO(struct ath10k ar, const void data, size_t len),
5ce8e7fd RM	426
	427	TP_ARGS(ar, data, len),
	428
	429	TP_STRUCT__entry(
	430	__string(device, dev_name(ar->dev))
	431	__string(driver, dev_driver_string(ar->dev))
04ae87a5	432	__field(u8, hw_type)
5ce8e7fd RM	433	__field(u16, len)
	434	__dynamic_array(u8, rxdesc, len)
	435	),
	436
	437	TP_fast_assign(
2c92ca84 SRG	438	__assign_str(device);
2c92ca84 SRG	439	__assign_str(driver);
18353749	440	__entry->hw_type = ar->hw_rev;
5ce8e7fd RM	441	__entry->len = len;
	442	memcpy(__get_dynamic_array(rxdesc), data, len);
	443	),
	444
	445	TP_printk(
18353749	446	"%s %s %d rxdesc len %d",
5ce8e7fd RM	447	__get_str(driver),
5ce8e7fd RM	448	__get_str(device),
18353749	449	__entry->hw_type,
5ce8e7fd RM	450	__entry->len
	451	)
	452	);
	453
04de6c6c MK	454	TRACE_EVENT(ath10k_wmi_diag_container,
	455	TP_PROTO(struct ath10k *ar,
	456	u8 type,
	457	u32 timestamp,
	458	u32 code,
	459	u16 len,
	460	const void *data),
	461
	462	TP_ARGS(ar, type, timestamp, code, len, data),
	463
	464	TP_STRUCT__entry(
	465	__string(device, dev_name(ar->dev))
	466	__string(driver, dev_driver_string(ar->dev))
	467	__field(u8, type)
	468	__field(u32, timestamp)
	469	__field(u32, code)
	470	__field(u16, len)
	471	__dynamic_array(u8, data, len)
	472	),
	473
	474	TP_fast_assign(
2c92ca84 SRG	475	__assign_str(device);
2c92ca84 SRG	476	__assign_str(driver);
04de6c6c MK	477	__entry->type = type;
	478	__entry->timestamp = timestamp;
	479	__entry->code = code;
	480	__entry->len = len;
	481	memcpy(__get_dynamic_array(data), data, len);
	482	),
	483
	484	TP_printk(
779750bb	485	"%s %s diag container type %u timestamp %u code %u len %d",
04de6c6c MK	486	__get_str(driver),
	487	__get_str(device),
	488	__entry->type,
	489	__entry->timestamp,
	490	__entry->code,
	491	__entry->len
	492	)
	493	);
	494
c3113c39 MK	495	TRACE_EVENT(ath10k_wmi_diag,
	496	TP_PROTO(struct ath10k ar, const void data, size_t len),
	497
	498	TP_ARGS(ar, data, len),
	499
	500	TP_STRUCT__entry(
	501	__string(device, dev_name(ar->dev))
	502	__string(driver, dev_driver_string(ar->dev))
	503	__field(u16, len)
	504	__dynamic_array(u8, data, len)
	505	),
	506
	507	TP_fast_assign(
2c92ca84 SRG	508	__assign_str(device);
2c92ca84 SRG	509	__assign_str(driver);
c3113c39 MK	510	__entry->len = len;
	511	memcpy(__get_dynamic_array(data), data, len);
	512	),
	513
	514	TP_printk(
	515	"%s %s tlv diag len %d",
	516	__get_str(driver),
	517	__get_str(device),
	518	__entry->len
	519	)
	520	);
	521
5e3dd157 KV	522	#endif /* _TRACE_H_ \|\| TRACE_HEADER_MULTI_READ*/
	523
	524	/* we don't want to use include/trace/events */
	525	#undef TRACE_INCLUDE_PATH
	526	#define TRACE_INCLUDE_PATH .
	527	#undef TRACE_INCLUDE_FILE
	528	#define TRACE_INCLUDE_FILE trace
	529
	530	/* This part must be outside protection */
	531	#include <trace/define_trace.h>