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 __vstring(msg, vaf->fmt, vaf->va) 56 ), 57 TP_fast_assign( 58 __assign_str(device); 59 __assign_str(driver); 60 __assign_vstr(msg, vaf->fmt, vaf->va); 61 ), 62 TP_printk( 63 "%s %s %s", 64 __get_str(driver), 65 __get_str(device), 66 __get_str(msg) 67 ) 68 ); 69 70 DEFINE_EVENT(ath10k_log_event, ath10k_log_err, 71 TP_PROTO(struct ath10k *ar, struct va_format *vaf), 72 TP_ARGS(ar, vaf) 73 ); 74 75 DEFINE_EVENT(ath10k_log_event, ath10k_log_warn, 76 TP_PROTO(struct ath10k *ar, struct va_format *vaf), 77 TP_ARGS(ar, vaf) 78 ); 79 80 DEFINE_EVENT(ath10k_log_event, ath10k_log_info, 81 TP_PROTO(struct ath10k *ar, struct va_format *vaf), 82 TP_ARGS(ar, vaf) 83 ); 84 85 TRACE_EVENT(ath10k_log_dbg, 86 TP_PROTO(struct ath10k *ar, unsigned int level, struct va_format *vaf), 87 TP_ARGS(ar, level, vaf), 88 TP_STRUCT__entry( 89 __string(device, dev_name(ar->dev)) 90 __string(driver, dev_driver_string(ar->dev)) 91 __field(unsigned int, level) 92 __vstring(msg, vaf->fmt, vaf->va) 93 ), 94 TP_fast_assign( 95 __assign_str(device); 96 __assign_str(driver); 97 __entry->level = level; 98 __assign_vstr(msg, vaf->fmt, vaf->va); 99 ), 100 TP_printk( 101 "%s %s %s", 102 __get_str(driver), 103 __get_str(device), 104 __get_str(msg) 105 ) 106 ); 107 108 TRACE_EVENT(ath10k_log_dbg_dump, 109 TP_PROTO(struct ath10k *ar, const char *msg, const char *prefix, 110 const void *buf, size_t buf_len), 111 112 TP_ARGS(ar, msg, prefix, buf, buf_len), 113 114 TP_STRUCT__entry( 115 __string(device, dev_name(ar->dev)) 116 __string(driver, dev_driver_string(ar->dev)) 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( 124 __assign_str(device); 125 __assign_str(driver); 126 __assign_str(msg); 127 __assign_str(prefix); 128 __entry->buf_len = buf_len; 129 memcpy(__get_dynamic_array(buf), buf, buf_len); 130 ), 131 132 TP_printk( 133 "%s %s %s/%s\n", 134 __get_str(driver), 135 __get_str(device), 136 __get_str(prefix), 137 __get_str(msg) 138 ) 139 ); 140 141 TRACE_EVENT(ath10k_wmi_cmd, 142 TP_PROTO(struct ath10k *ar, int id, const void *buf, size_t buf_len), 143 144 TP_ARGS(ar, id, buf, buf_len), 145 146 TP_STRUCT__entry( 147 __string(device, dev_name(ar->dev)) 148 __string(driver, dev_driver_string(ar->dev)) 149 __field(unsigned int, id) 150 __field(size_t, buf_len) 151 __dynamic_array(u8, buf, buf_len) 152 ), 153 154 TP_fast_assign( 155 __assign_str(device); 156 __assign_str(driver); 157 __entry->id = id; 158 __entry->buf_len = buf_len; 159 memcpy(__get_dynamic_array(buf), buf, buf_len); 160 ), 161 162 TP_printk( 163 "%s %s id %d len %zu", 164 __get_str(driver), 165 __get_str(device), 166 __entry->id, 167 __entry->buf_len 168 ) 169 ); 170 171 TRACE_EVENT(ath10k_wmi_event, 172 TP_PROTO(struct ath10k *ar, int id, const void *buf, size_t buf_len), 173 174 TP_ARGS(ar, id, buf, buf_len), 175 176 TP_STRUCT__entry( 177 __string(device, dev_name(ar->dev)) 178 __string(driver, dev_driver_string(ar->dev)) 179 __field(unsigned int, id) 180 __field(size_t, buf_len) 181 __dynamic_array(u8, buf, buf_len) 182 ), 183 184 TP_fast_assign( 185 __assign_str(device); 186 __assign_str(driver); 187 __entry->id = id; 188 __entry->buf_len = buf_len; 189 memcpy(__get_dynamic_array(buf), buf, buf_len); 190 ), 191 192 TP_printk( 193 "%s %s id %d len %zu", 194 __get_str(driver), 195 __get_str(device), 196 __entry->id, 197 __entry->buf_len 198 ) 199 ); 200 201 TRACE_EVENT(ath10k_htt_stats, 202 TP_PROTO(struct ath10k *ar, const void *buf, size_t buf_len), 203 204 TP_ARGS(ar, buf, buf_len), 205 206 TP_STRUCT__entry( 207 __string(device, dev_name(ar->dev)) 208 __string(driver, dev_driver_string(ar->dev)) 209 __field(size_t, buf_len) 210 __dynamic_array(u8, buf, buf_len) 211 ), 212 213 TP_fast_assign( 214 __assign_str(device); 215 __assign_str(driver); 216 __entry->buf_len = buf_len; 217 memcpy(__get_dynamic_array(buf), buf, buf_len); 218 ), 219 220 TP_printk( 221 "%s %s len %zu", 222 __get_str(driver), 223 __get_str(device), 224 __entry->buf_len 225 ) 226 ); 227 228 TRACE_EVENT(ath10k_wmi_dbglog, 229 TP_PROTO(struct ath10k *ar, const void *buf, size_t buf_len), 230 231 TP_ARGS(ar, buf, buf_len), 232 233 TP_STRUCT__entry( 234 __string(device, dev_name(ar->dev)) 235 __string(driver, dev_driver_string(ar->dev)) 236 __field(u8, hw_type) 237 __field(size_t, buf_len) 238 __dynamic_array(u8, buf, buf_len) 239 ), 240 241 TP_fast_assign( 242 __assign_str(device); 243 __assign_str(driver); 244 __entry->hw_type = ar->hw_rev; 245 __entry->buf_len = buf_len; 246 memcpy(__get_dynamic_array(buf), buf, buf_len); 247 ), 248 249 TP_printk( 250 "%s %s %d len %zu", 251 __get_str(driver), 252 __get_str(device), 253 __entry->hw_type, 254 __entry->buf_len 255 ) 256 ); 257 258 TRACE_EVENT(ath10k_htt_pktlog, 259 TP_PROTO(struct ath10k *ar, const void *buf, u16 buf_len), 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)) 266 __field(u8, hw_type) 267 __field(u16, buf_len) 268 __dynamic_array(u8, pktlog, buf_len) 269 ), 270 271 TP_fast_assign( 272 __assign_str(device); 273 __assign_str(driver); 274 __entry->hw_type = ar->hw_rev; 275 __entry->buf_len = buf_len; 276 memcpy(__get_dynamic_array(pktlog), buf, buf_len); 277 ), 278 279 TP_printk( 280 "%s %s %d size %u", 281 __get_str(driver), 282 __get_str(device), 283 __entry->hw_type, 284 __entry->buf_len 285 ) 286 ); 287 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( 304 __assign_str(device); 305 __assign_str(driver); 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( 335 __assign_str(device); 336 __assign_str(driver); 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 ); 347 348 DECLARE_EVENT_CLASS(ath10k_hdr_event, 349 TP_PROTO(struct ath10k *ar, const void *data, size_t len), 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) 357 __dynamic_array(u8, data, ath10k_frm_hdr_len(data, len)) 358 ), 359 360 TP_fast_assign( 361 __assign_str(device); 362 __assign_str(driver); 363 __entry->len = ath10k_frm_hdr_len(data, len); 364 memcpy(__get_dynamic_array(data), data, __entry->len); 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 375 DECLARE_EVENT_CLASS(ath10k_payload_event, 376 TP_PROTO(struct ath10k *ar, const void *data, size_t len), 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) 384 __dynamic_array(u8, payload, (len - 385 ath10k_frm_hdr_len(data, len))) 386 ), 387 388 TP_fast_assign( 389 __assign_str(device); 390 __assign_str(driver); 391 __entry->len = len - ath10k_frm_hdr_len(data, len); 392 memcpy(__get_dynamic_array(payload), 393 data + ath10k_frm_hdr_len(data, len), __entry->len); 394 ), 395 396 TP_printk( 397 "%s %s len %zu\n", 398 __get_str(driver), 399 __get_str(device), 400 __entry->len 401 ) 402 ); 403 404 DEFINE_EVENT(ath10k_hdr_event, ath10k_tx_hdr, 405 TP_PROTO(struct ath10k *ar, const void *data, size_t len), 406 TP_ARGS(ar, data, len) 407 ); 408 409 DEFINE_EVENT(ath10k_payload_event, ath10k_tx_payload, 410 TP_PROTO(struct ath10k *ar, const void *data, size_t len), 411 TP_ARGS(ar, data, len) 412 ); 413 414 DEFINE_EVENT(ath10k_hdr_event, ath10k_rx_hdr, 415 TP_PROTO(struct ath10k *ar, const void *data, size_t len), 416 TP_ARGS(ar, data, len) 417 ); 418 419 DEFINE_EVENT(ath10k_payload_event, ath10k_rx_payload, 420 TP_PROTO(struct ath10k *ar, const void *data, size_t len), 421 TP_ARGS(ar, data, len) 422 ); 423 424 TRACE_EVENT(ath10k_htt_rx_desc, 425 TP_PROTO(struct ath10k *ar, const void *data, size_t len), 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)) 432 __field(u8, hw_type) 433 __field(u16, len) 434 __dynamic_array(u8, rxdesc, len) 435 ), 436 437 TP_fast_assign( 438 __assign_str(device); 439 __assign_str(driver); 440 __entry->hw_type = ar->hw_rev; 441 __entry->len = len; 442 memcpy(__get_dynamic_array(rxdesc), data, len); 443 ), 444 445 TP_printk( 446 "%s %s %d rxdesc len %d", 447 __get_str(driver), 448 __get_str(device), 449 __entry->hw_type, 450 __entry->len 451 ) 452 ); 453 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( 475 __assign_str(device); 476 __assign_str(driver); 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( 485 "%s %s diag container type %u timestamp %u code %u len %d", 486 __get_str(driver), 487 __get_str(device), 488 __entry->type, 489 __entry->timestamp, 490 __entry->code, 491 __entry->len 492 ) 493 ); 494 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( 508 __assign_str(device); 509 __assign_str(driver); 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 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> 532