ath/ath11k/trace.h

0001 /* SPDX-License-Identifier: BSD-3-Clause-Clear */
0002 /*
0003  * Copyright (c) 2019 The Linux Foundation. All rights reserved.
0004  */
0005
0006 #if !defined(_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
0007
0008 #include <linux/tracepoint.h>
0009 #include "core.h"
0010
0011 #define _TRACE_H_
0012
0013 /* create empty functions when tracing is disabled */
0014 #if !defined(CONFIG_ATH11K_TRACING)
0015 #undef TRACE_EVENT
0016 #define TRACE_EVENT(name, proto, ...) \
0017 static inline void trace_ ## name(proto) {} \
0018 static inline bool trace_##name##_enabled(void) \
0019 {                       \
0020     return false;               \
0021 }
0022
0023 #undef DECLARE_EVENT_CLASS
0024 #define DECLARE_EVENT_CLASS(...)
0025 #undef DEFINE_EVENT
0026 #define DEFINE_EVENT(evt_class, name, proto, ...) \
0027 static inline void trace_ ## name(proto) {}
0028 #endif /* !CONFIG_ATH11K_TRACING || __CHECKER__ */
0029
0030 #undef TRACE_SYSTEM
0031 #define TRACE_SYSTEM ath11k
0032
0033 #define ATH11K_MSG_MAX 400
0034
0035 TRACE_EVENT(ath11k_htt_pktlog,
0036         TP_PROTO(struct ath11k *ar, const void *buf, u16 buf_len,
0037              u32 pktlog_checksum),
0038
0039     TP_ARGS(ar, buf, buf_len, pktlog_checksum),
0040
0041     TP_STRUCT__entry(
0042         __string(device, dev_name(ar->ab->dev))
0043         __string(driver, dev_driver_string(ar->ab->dev))
0044         __field(u16, buf_len)
0045         __field(u32, pktlog_checksum)
0046         __dynamic_array(u8, pktlog, buf_len)
0047     ),
0048
0049     TP_fast_assign(
0050         __assign_str(device, dev_name(ar->ab->dev));
0051         __assign_str(driver, dev_driver_string(ar->ab->dev));
0052         __entry->buf_len = buf_len;
0053         __entry->pktlog_checksum = pktlog_checksum;
0054         memcpy(__get_dynamic_array(pktlog), buf, buf_len);
0055     ),
0056
0057     TP_printk(
0058         "%s %s size %u pktlog_checksum %d",
0059         __get_str(driver),
0060         __get_str(device),
0061         __entry->buf_len,
0062         __entry->pktlog_checksum
0063      )
0064 );
0065
0066 TRACE_EVENT(ath11k_htt_ppdu_stats,
0067         TP_PROTO(struct ath11k *ar, const void *data, size_t len),
0068
0069     TP_ARGS(ar, data, len),
0070
0071     TP_STRUCT__entry(
0072         __string(device, dev_name(ar->ab->dev))
0073         __string(driver, dev_driver_string(ar->ab->dev))
0074         __field(u16, len)
0075         __dynamic_array(u8, ppdu, len)
0076     ),
0077
0078     TP_fast_assign(
0079         __assign_str(device, dev_name(ar->ab->dev));
0080         __assign_str(driver, dev_driver_string(ar->ab->dev));
0081         __entry->len = len;
0082         memcpy(__get_dynamic_array(ppdu), data, len);
0083     ),
0084
0085     TP_printk(
0086         "%s %s ppdu len %d",
0087         __get_str(driver),
0088         __get_str(device),
0089         __entry->len
0090      )
0091 );
0092
0093 TRACE_EVENT(ath11k_htt_rxdesc,
0094         TP_PROTO(struct ath11k *ar, const void *data, size_t log_type, size_t len),
0095
0096     TP_ARGS(ar, data, log_type, len),
0097
0098     TP_STRUCT__entry(
0099         __string(device, dev_name(ar->ab->dev))
0100         __string(driver, dev_driver_string(ar->ab->dev))
0101         __field(u16, len)
0102         __field(u16, log_type)
0103         __dynamic_array(u8, rxdesc, len)
0104     ),
0105
0106     TP_fast_assign(
0107         __assign_str(device, dev_name(ar->ab->dev));
0108         __assign_str(driver, dev_driver_string(ar->ab->dev));
0109         __entry->len = len;
0110         __entry->log_type = log_type;
0111         memcpy(__get_dynamic_array(rxdesc), data, len);
0112     ),
0113
0114     TP_printk(
0115         "%s %s rxdesc len %d type %d",
0116         __get_str(driver),
0117         __get_str(device),
0118         __entry->len,
0119         __entry->log_type
0120      )
0121 );
0122
0123 DECLARE_EVENT_CLASS(ath11k_log_event,
0124             TP_PROTO(struct ath11k_base *ab, struct va_format *vaf),
0125     TP_ARGS(ab, vaf),
0126     TP_STRUCT__entry(
0127         __string(device, dev_name(ab->dev))
0128         __string(driver, dev_driver_string(ab->dev))
0129         __vstring(msg, vaf->fmt, vaf->va)
0130     ),
0131     TP_fast_assign(
0132         __assign_str(device, dev_name(ab->dev));
0133         __assign_str(driver, dev_driver_string(ab->dev));
0134         __assign_vstr(msg, vaf->fmt, vaf->va);
0135     ),
0136     TP_printk(
0137         "%s %s %s",
0138         __get_str(driver),
0139         __get_str(device),
0140         __get_str(msg)
0141     )
0142 );
0143
0144 DEFINE_EVENT(ath11k_log_event, ath11k_log_err,
0145          TP_PROTO(struct ath11k_base *ab, struct va_format *vaf),
0146          TP_ARGS(ab, vaf)
0147 );
0148
0149 DEFINE_EVENT(ath11k_log_event, ath11k_log_warn,
0150          TP_PROTO(struct ath11k_base *ab, struct va_format *vaf),
0151          TP_ARGS(ab, vaf)
0152 );
0153
0154 DEFINE_EVENT(ath11k_log_event, ath11k_log_info,
0155          TP_PROTO(struct ath11k_base *ab, struct va_format *vaf),
0156          TP_ARGS(ab, vaf)
0157 );
0158
0159 TRACE_EVENT(ath11k_wmi_cmd,
0160         TP_PROTO(struct ath11k_base *ab, int id, const void *buf, size_t buf_len),
0161
0162     TP_ARGS(ab, id, buf, buf_len),
0163
0164     TP_STRUCT__entry(
0165         __string(device, dev_name(ab->dev))
0166         __string(driver, dev_driver_string(ab->dev))
0167         __field(unsigned int, id)
0168         __field(size_t, buf_len)
0169         __dynamic_array(u8, buf, buf_len)
0170     ),
0171
0172     TP_fast_assign(
0173         __assign_str(device, dev_name(ab->dev));
0174         __assign_str(driver, dev_driver_string(ab->dev));
0175         __entry->id = id;
0176         __entry->buf_len = buf_len;
0177         memcpy(__get_dynamic_array(buf), buf, buf_len);
0178     ),
0179
0180     TP_printk(
0181         "%s %s id %d len %zu",
0182         __get_str(driver),
0183         __get_str(device),
0184         __entry->id,
0185         __entry->buf_len
0186      )
0187 );
0188
0189 TRACE_EVENT(ath11k_wmi_event,
0190         TP_PROTO(struct ath11k_base *ab, int id, const void *buf, size_t buf_len),
0191
0192     TP_ARGS(ab, id, buf, buf_len),
0193
0194     TP_STRUCT__entry(
0195         __string(device, dev_name(ab->dev))
0196         __string(driver, dev_driver_string(ab->dev))
0197         __field(unsigned int, id)
0198         __field(size_t, buf_len)
0199         __dynamic_array(u8, buf, buf_len)
0200     ),
0201
0202     TP_fast_assign(
0203         __assign_str(device, dev_name(ab->dev));
0204         __assign_str(driver, dev_driver_string(ab->dev));
0205         __entry->id = id;
0206         __entry->buf_len = buf_len;
0207         memcpy(__get_dynamic_array(buf), buf, buf_len);
0208     ),
0209
0210     TP_printk(
0211         "%s %s id %d len %zu",
0212         __get_str(driver),
0213         __get_str(device),
0214         __entry->id,
0215         __entry->buf_len
0216     )
0217 );
0218
0219 TRACE_EVENT(ath11k_log_dbg,
0220         TP_PROTO(struct ath11k_base *ab, unsigned int level, struct va_format *vaf),
0221
0222     TP_ARGS(ab, level, vaf),
0223
0224     TP_STRUCT__entry(
0225         __string(device, dev_name(ab->dev))
0226         __string(driver, dev_driver_string(ab->dev))
0227         __field(unsigned int, level)
0228         __dynamic_array(char, msg, ATH11K_MSG_MAX)
0229     ),
0230
0231     TP_fast_assign(
0232         __assign_str(device, dev_name(ab->dev));
0233         __assign_str(driver, dev_driver_string(ab->dev));
0234         __entry->level = level;
0235         WARN_ON_ONCE(vsnprintf(__get_dynamic_array(msg),
0236                        ATH11K_MSG_MAX, vaf->fmt,
0237                        *vaf->va) >= ATH11K_MSG_MAX);
0238     ),
0239
0240     TP_printk(
0241         "%s %s %s",
0242         __get_str(driver),
0243         __get_str(device),
0244         __get_str(msg)
0245     )
0246 );
0247
0248 TRACE_EVENT(ath11k_log_dbg_dump,
0249         TP_PROTO(struct ath11k_base *ab, const char *msg, const char *prefix,
0250              const void *buf, size_t buf_len),
0251
0252     TP_ARGS(ab, msg, prefix, buf, buf_len),
0253
0254     TP_STRUCT__entry(
0255         __string(device, dev_name(ab->dev))
0256         __string(driver, dev_driver_string(ab->dev))
0257         __string(msg, msg)
0258         __string(prefix, prefix)
0259         __field(size_t, buf_len)
0260         __dynamic_array(u8, buf, buf_len)
0261     ),
0262
0263     TP_fast_assign(
0264         __assign_str(device, dev_name(ab->dev));
0265         __assign_str(driver, dev_driver_string(ab->dev));
0266         __assign_str(msg, msg);
0267         __assign_str(prefix, prefix);
0268         __entry->buf_len = buf_len;
0269         memcpy(__get_dynamic_array(buf), buf, buf_len);
0270     ),
0271
0272     TP_printk(
0273         "%s %s %s/%s\n",
0274         __get_str(driver),
0275         __get_str(device),
0276         __get_str(prefix),
0277         __get_str(msg)
0278     )
0279 );
0280
0281 TRACE_EVENT(ath11k_wmi_diag,
0282         TP_PROTO(struct ath11k_base *ab, const void *data, size_t len),
0283
0284     TP_ARGS(ab, data, len),
0285
0286     TP_STRUCT__entry(
0287         __string(device, dev_name(ab->dev))
0288         __string(driver, dev_driver_string(ab->dev))
0289         __field(u16, len)
0290         __dynamic_array(u8, data, len)
0291     ),
0292
0293     TP_fast_assign(
0294         __assign_str(device, dev_name(ab->dev));
0295         __assign_str(driver, dev_driver_string(ab->dev));
0296         __entry->len = len;
0297         memcpy(__get_dynamic_array(data), data, len);
0298     ),
0299
0300     TP_printk(
0301         "%s %s tlv diag len %d",
0302         __get_str(driver),
0303         __get_str(device),
0304         __entry->len
0305     )
0306 );
0307
0308 #endif /* _TRACE_H_ || TRACE_HEADER_MULTI_READ*/
0309
0310 /* we don't want to use include/trace/events */
0311 #undef TRACE_INCLUDE_PATH
0312 #define TRACE_INCLUDE_PATH .
0313 #undef TRACE_INCLUDE_FILE
0314 #define TRACE_INCLUDE_FILE trace
0315
0316 /* This part must be outside protection */
0317 #include <trace/define_trace.h>