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

   1 /*
   2  * Copyright (c) 2005-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #if !defined(_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
  19
  20 #include <linux/tracepoint.h>
  21 #include "core.h"
  22
  23 #if !defined(_TRACE_H_)
  24 static inline u32 ath10k_frm_hdr_len(void *buf)
  25 {
  26         return ieee80211_hdrlen(((struct ieee80211_hdr *)buf)->frame_control);
  27 }
  28 #endif
  29
  30 #define _TRACE_H_
  31
  32 /* create empty functions when tracing is disabled */
  33 #if !defined(CONFIG_ATH10K_TRACING)
  34 #undef TRACE_EVENT
  35 #define TRACE_EVENT(name, proto, ...) \
  36 static inline void trace_ ## name(proto) {}
  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 200
  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, void *buf, size_t buf_len, int ret),
 149
 150         TP_ARGS(ar, id, buf, buf_len, ret),
 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                 __field(int, ret)
 159         ),
 160
 161         TP_fast_assign(
 162                 __assign_str(device, dev_name(ar->dev));
 163                 __assign_str(driver, dev_driver_string(ar->dev));
 164                 __entry->id = id;
 165                 __entry->buf_len = buf_len;
 166                 __entry->ret = ret;
 167                 memcpy(__get_dynamic_array(buf), buf, buf_len);
 168         ),
 169
 170         TP_printk(
 171                 "%s %s id %d len %zu ret %d",
 172                 __get_str(driver),
 173                 __get_str(device),
 174                 __entry->id,
 175                 __entry->buf_len,
 176                 __entry->ret
 177         )
 178 );
 179
 180 TRACE_EVENT(ath10k_wmi_event,
 181         TP_PROTO(struct ath10k *ar, int id, void *buf, size_t buf_len),
 182
 183         TP_ARGS(ar, id, buf, buf_len),
 184
 185         TP_STRUCT__entry(
 186                 __string(device, dev_name(ar->dev))
 187                 __string(driver, dev_driver_string(ar->dev))
 188                 __field(unsigned int, id)
 189                 __field(size_t, buf_len)
 190                 __dynamic_array(u8, buf, buf_len)
 191         ),
 192
 193         TP_fast_assign(
 194                 __assign_str(device, dev_name(ar->dev));
 195                 __assign_str(driver, dev_driver_string(ar->dev));
 196                 __entry->id = id;
 197                 __entry->buf_len = buf_len;
 198                 memcpy(__get_dynamic_array(buf), buf, buf_len);
 199         ),
 200
 201         TP_printk(
 202                 "%s %s id %d len %zu",
 203                 __get_str(driver),
 204                 __get_str(device),
 205                 __entry->id,
 206                 __entry->buf_len
 207         )
 208 );
 209
 210 TRACE_EVENT(ath10k_htt_stats,
 211         TP_PROTO(struct ath10k *ar, void *buf, size_t buf_len),
 212
 213         TP_ARGS(ar, buf, buf_len),
 214
 215         TP_STRUCT__entry(
 216                 __string(device, dev_name(ar->dev))
 217                 __string(driver, dev_driver_string(ar->dev))
 218                 __field(size_t, buf_len)
 219                 __dynamic_array(u8, buf, buf_len)
 220         ),
 221
 222         TP_fast_assign(
 223                 __assign_str(device, dev_name(ar->dev));
 224                 __assign_str(driver, dev_driver_string(ar->dev));
 225                 __entry->buf_len = buf_len;
 226                 memcpy(__get_dynamic_array(buf), buf, buf_len);
 227         ),
 228
 229         TP_printk(
 230                 "%s %s len %zu",
 231                 __get_str(driver),
 232                 __get_str(device),
 233                 __entry->buf_len
 234         )
 235 );
 236
 237 TRACE_EVENT(ath10k_wmi_dbglog,
 238         TP_PROTO(struct ath10k *ar, void *buf, size_t buf_len),
 239
 240         TP_ARGS(ar, buf, buf_len),
 241
 242         TP_STRUCT__entry(
 243                 __string(device, dev_name(ar->dev))
 244                 __string(driver, dev_driver_string(ar->dev))
 245                 __field(size_t, buf_len)
 246                 __dynamic_array(u8, buf, buf_len)
 247         ),
 248
 249         TP_fast_assign(
 250                 __assign_str(device, dev_name(ar->dev));
 251                 __assign_str(driver, dev_driver_string(ar->dev));
 252                 __entry->buf_len = buf_len;
 253                 memcpy(__get_dynamic_array(buf), buf, buf_len);
 254         ),
 255
 256         TP_printk(
 257                 "%s %s len %zu",
 258                 __get_str(driver),
 259                 __get_str(device),
 260                 __entry->buf_len
 261         )
 262 );
 263
 264 TRACE_EVENT(ath10k_htt_pktlog,
 265             TP_PROTO(struct ath10k *ar, 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(u16, buf_len)
 273                 __dynamic_array(u8, pktlog, buf_len)
 274         ),
 275
 276         TP_fast_assign(
 277                 __assign_str(device, dev_name(ar->dev));
 278                 __assign_str(driver, dev_driver_string(ar->dev));
 279                 __entry->buf_len = buf_len;
 280                 memcpy(__get_dynamic_array(pktlog), buf, buf_len);
 281         ),
 282
 283         TP_printk(
 284                 "%s %s size %hu",
 285                 __get_str(driver),
 286                 __get_str(device),
 287                 __entry->buf_len
 288          )
 289 );
 290
 291 TRACE_EVENT(ath10k_htt_tx,
 292             TP_PROTO(struct ath10k *ar, u16 msdu_id, u16 msdu_len,
 293                      u8 vdev_id, u8 tid),
 294
 295         TP_ARGS(ar, msdu_id, msdu_len, vdev_id, tid),
 296
 297         TP_STRUCT__entry(
 298                 __string(device, dev_name(ar->dev))
 299                 __string(driver, dev_driver_string(ar->dev))
 300                 __field(u16, msdu_id)
 301                 __field(u16, msdu_len)
 302                 __field(u8, vdev_id)
 303                 __field(u8, tid)
 304         ),
 305
 306         TP_fast_assign(
 307                 __assign_str(device, dev_name(ar->dev));
 308                 __assign_str(driver, dev_driver_string(ar->dev));
 309                 __entry->msdu_id = msdu_id;
 310                 __entry->msdu_len = msdu_len;
 311                 __entry->vdev_id = vdev_id;
 312                 __entry->tid = tid;
 313         ),
 314
 315         TP_printk(
 316                 "%s %s msdu_id %d msdu_len %d vdev_id %d tid %d",
 317                 __get_str(driver),
 318                 __get_str(device),
 319                 __entry->msdu_id,
 320                 __entry->msdu_len,
 321                 __entry->vdev_id,
 322                 __entry->tid
 323          )
 324 );
 325
 326 TRACE_EVENT(ath10k_txrx_tx_unref,
 327             TP_PROTO(struct ath10k *ar, u16 msdu_id),
 328
 329         TP_ARGS(ar, msdu_id),
 330
 331         TP_STRUCT__entry(
 332                 __string(device, dev_name(ar->dev))
 333                 __string(driver, dev_driver_string(ar->dev))
 334                 __field(u16, msdu_id)
 335         ),
 336
 337         TP_fast_assign(
 338                 __assign_str(device, dev_name(ar->dev));
 339                 __assign_str(driver, dev_driver_string(ar->dev));
 340                 __entry->msdu_id = msdu_id;
 341         ),
 342
 343         TP_printk(
 344                 "%s %s msdu_id %d",
 345                 __get_str(driver),
 346                 __get_str(device),
 347                 __entry->msdu_id
 348          )
 349 );
 350
 351 DECLARE_EVENT_CLASS(ath10k_hdr_event,
 352                     TP_PROTO(struct ath10k *ar, void *data, size_t len),
 353
 354         TP_ARGS(ar, data, len),
 355
 356         TP_STRUCT__entry(
 357                 __string(device, dev_name(ar->dev))
 358                 __string(driver, dev_driver_string(ar->dev))
 359                 __field(size_t, len)
 360                 __dynamic_array(u8, data, ath10k_frm_hdr_len(data))
 361         ),
 362
 363         TP_fast_assign(
 364                 __assign_str(device, dev_name(ar->dev));
 365                 __assign_str(driver, dev_driver_string(ar->dev));
 366                 __entry->len = ath10k_frm_hdr_len(data);
 367                 memcpy(__get_dynamic_array(data), data, __entry->len);
 368         ),
 369
 370         TP_printk(
 371                 "%s %s len %zu\n",
 372                 __get_str(driver),
 373                 __get_str(device),
 374                 __entry->len
 375         )
 376 );
 377
 378 DECLARE_EVENT_CLASS(ath10k_payload_event,
 379                     TP_PROTO(struct ath10k *ar, void *data, size_t len),
 380
 381         TP_ARGS(ar, data, len),
 382
 383         TP_STRUCT__entry(
 384                 __string(device, dev_name(ar->dev))
 385                 __string(driver, dev_driver_string(ar->dev))
 386                 __field(size_t, len)
 387                 __dynamic_array(u8, payload, (len - ath10k_frm_hdr_len(data)))
 388         ),
 389
 390         TP_fast_assign(
 391                 __assign_str(device, dev_name(ar->dev));
 392                 __assign_str(driver, dev_driver_string(ar->dev));
 393                 __entry->len = len - ath10k_frm_hdr_len(data);
 394                 memcpy(__get_dynamic_array(payload),
 395                        data + ath10k_frm_hdr_len(data), __entry->len);
 396         ),
 397
 398         TP_printk(
 399                 "%s %s len %zu\n",
 400                 __get_str(driver),
 401                 __get_str(device),
 402                 __entry->len
 403         )
 404 );
 405
 406 DEFINE_EVENT(ath10k_hdr_event, ath10k_tx_hdr,
 407              TP_PROTO(struct ath10k *ar, void *data, size_t len),
 408              TP_ARGS(ar, data, len)
 409 );
 410
 411 DEFINE_EVENT(ath10k_payload_event, ath10k_tx_payload,
 412              TP_PROTO(struct ath10k *ar, void *data, size_t len),
 413              TP_ARGS(ar, data, len)
 414 );
 415
 416 DEFINE_EVENT(ath10k_hdr_event, ath10k_rx_hdr,
 417              TP_PROTO(struct ath10k *ar, void *data, size_t len),
 418              TP_ARGS(ar, data, len)
 419 );
 420
 421 DEFINE_EVENT(ath10k_payload_event, ath10k_rx_payload,
 422              TP_PROTO(struct ath10k *ar, void *data, size_t len),
 423              TP_ARGS(ar, data, len)
 424 );
 425
 426 TRACE_EVENT(ath10k_htt_rx_desc,
 427             TP_PROTO(struct ath10k *ar, void *data, size_t len),
 428
 429         TP_ARGS(ar, data, len),
 430
 431         TP_STRUCT__entry(
 432                 __string(device, dev_name(ar->dev))
 433                 __string(driver, dev_driver_string(ar->dev))
 434                 __field(u16, len)
 435                 __dynamic_array(u8, rxdesc, len)
 436         ),
 437
 438         TP_fast_assign(
 439                 __assign_str(device, dev_name(ar->dev));
 440                 __assign_str(driver, dev_driver_string(ar->dev));
 441                 __entry->len = len;
 442                 memcpy(__get_dynamic_array(rxdesc), data, len);
 443         ),
 444
 445         TP_printk(
 446                 "%s %s rxdesc len %d",
 447                 __get_str(driver),
 448                 __get_str(device),
 449                 __entry->len
 450          )
 451 );
 452
 453 #endif /* _TRACE_H_ || TRACE_HEADER_MULTI_READ*/
 454
 455 /* we don't want to use include/trace/events */
 456 #undef TRACE_INCLUDE_PATH
 457 #define TRACE_INCLUDE_PATH .
 458 #undef TRACE_INCLUDE_FILE
 459 #define TRACE_INCLUDE_FILE trace
 460
 461 /* This part must be outside protection */
 462 #include <trace/define_trace.h>