drivers/net/wireless/ath/ath10k/trace.h

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