drivers/net/wireless/iwlwifi/iwl-devtrace.h

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2009 - 2013 Intel Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  * The full GNU General Public License is included in this distribution in the
  19  * file called LICENSE.
  20  *
  21  * Contact Information:
  22  *  Intel Linux Wireless <ilw@linux.intel.com>
  23  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  24  *
  25  *****************************************************************************/
  26
  27 #if !defined(__IWLWIFI_DEVICE_TRACE) || defined(TRACE_HEADER_MULTI_READ)
  28 #include <linux/skbuff.h>
  29 #include <linux/ieee80211.h>
  30 #include <net/cfg80211.h>
  31 #include "iwl-trans.h"
  32 #if !defined(__IWLWIFI_DEVICE_TRACE)
  33 static inline bool iwl_trace_data(struct sk_buff *skb)
  34 {
  35         struct ieee80211_hdr *hdr = (void *)skb->data;
  36         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  37
  38         if (!ieee80211_is_data(hdr->frame_control))
  39                 return false;
  40         return !(info->control.flags & IEEE80211_TX_CTRL_PORT_CTRL_PROTO);
  41 }
  42
  43 static inline size_t iwl_rx_trace_len(const struct iwl_trans *trans,
  44                                       void *rxbuf, size_t len)
  45 {
  46         struct iwl_cmd_header *cmd = (void *)((u8 *)rxbuf + sizeof(__le32));
  47         struct ieee80211_hdr *hdr;
  48
  49         if (cmd->cmd != trans->rx_mpdu_cmd)
  50                 return len;
  51
  52         hdr = (void *)((u8 *)cmd + sizeof(struct iwl_cmd_header) +
  53                         trans->rx_mpdu_cmd_hdr_size);
  54         if (!ieee80211_is_data(hdr->frame_control))
  55                 return len;
  56         /* maybe try to identify EAPOL frames? */
  57         return sizeof(__le32) + sizeof(*cmd) + trans->rx_mpdu_cmd_hdr_size +
  58                 ieee80211_hdrlen(hdr->frame_control);
  59 }
  60 #endif
  61
  62 #define __IWLWIFI_DEVICE_TRACE
  63
  64 #include <linux/tracepoint.h>
  65 #include <linux/device.h>
  66 #include "iwl-trans.h"
  67
  68
  69 #if !defined(CONFIG_IWLWIFI_DEVICE_TRACING) || defined(__CHECKER__)
  70 #undef TRACE_EVENT
  71 #define TRACE_EVENT(name, proto, ...) \
  72 static inline void trace_ ## name(proto) {}
  73 #undef DECLARE_EVENT_CLASS
  74 #define DECLARE_EVENT_CLASS(...)
  75 #undef DEFINE_EVENT
  76 #define DEFINE_EVENT(evt_class, name, proto, ...) \
  77 static inline void trace_ ## name(proto) {}
  78 #endif
  79
  80 #define DEV_ENTRY       __string(dev, dev_name(dev))
  81 #define DEV_ASSIGN      __assign_str(dev, dev_name(dev))
  82
  83 #undef TRACE_SYSTEM
  84 #define TRACE_SYSTEM iwlwifi_io
  85
  86 TRACE_EVENT(iwlwifi_dev_ioread32,
  87         TP_PROTO(const struct device *dev, u32 offs, u32 val),
  88         TP_ARGS(dev, offs, val),
  89         TP_STRUCT__entry(
  90                 DEV_ENTRY
  91                 __field(u32, offs)
  92                 __field(u32, val)
  93         ),
  94         TP_fast_assign(
  95                 DEV_ASSIGN;
  96                 __entry->offs = offs;
  97                 __entry->val = val;
  98         ),
  99         TP_printk("[%s] read io[%#x] = %#x",
 100                   __get_str(dev), __entry->offs, __entry->val)
 101 );
 102
 103 TRACE_EVENT(iwlwifi_dev_iowrite8,
 104         TP_PROTO(const struct device *dev, u32 offs, u8 val),
 105         TP_ARGS(dev, offs, val),
 106         TP_STRUCT__entry(
 107                 DEV_ENTRY
 108                 __field(u32, offs)
 109                 __field(u8, val)
 110         ),
 111         TP_fast_assign(
 112                 DEV_ASSIGN;
 113                 __entry->offs = offs;
 114                 __entry->val = val;
 115         ),
 116         TP_printk("[%s] write io[%#x] = %#x)",
 117                   __get_str(dev), __entry->offs, __entry->val)
 118 );
 119
 120 TRACE_EVENT(iwlwifi_dev_iowrite32,
 121         TP_PROTO(const struct device *dev, u32 offs, u32 val),
 122         TP_ARGS(dev, offs, val),
 123         TP_STRUCT__entry(
 124                 DEV_ENTRY
 125                 __field(u32, offs)
 126                 __field(u32, val)
 127         ),
 128         TP_fast_assign(
 129                 DEV_ASSIGN;
 130                 __entry->offs = offs;
 131                 __entry->val = val;
 132         ),
 133         TP_printk("[%s] write io[%#x] = %#x)",
 134                   __get_str(dev), __entry->offs, __entry->val)
 135 );
 136
 137 TRACE_EVENT(iwlwifi_dev_iowrite_prph32,
 138         TP_PROTO(const struct device *dev, u32 offs, u32 val),
 139         TP_ARGS(dev, offs, val),
 140         TP_STRUCT__entry(
 141                 DEV_ENTRY
 142                 __field(u32, offs)
 143                 __field(u32, val)
 144         ),
 145         TP_fast_assign(
 146                 DEV_ASSIGN;
 147                 __entry->offs = offs;
 148                 __entry->val = val;
 149         ),
 150         TP_printk("[%s] write PRPH[%#x] = %#x)",
 151                   __get_str(dev), __entry->offs, __entry->val)
 152 );
 153
 154 TRACE_EVENT(iwlwifi_dev_ioread_prph32,
 155         TP_PROTO(const struct device *dev, u32 offs, u32 val),
 156         TP_ARGS(dev, offs, val),
 157         TP_STRUCT__entry(
 158                 DEV_ENTRY
 159                 __field(u32, offs)
 160                 __field(u32, val)
 161         ),
 162         TP_fast_assign(
 163                 DEV_ASSIGN;
 164                 __entry->offs = offs;
 165                 __entry->val = val;
 166         ),
 167         TP_printk("[%s] read PRPH[%#x] = %#x",
 168                   __get_str(dev), __entry->offs, __entry->val)
 169 );
 170
 171 TRACE_EVENT(iwlwifi_dev_irq,
 172         TP_PROTO(const struct device *dev),
 173         TP_ARGS(dev),
 174         TP_STRUCT__entry(
 175                 DEV_ENTRY
 176         ),
 177         TP_fast_assign(
 178                 DEV_ASSIGN;
 179         ),
 180         /* TP_printk("") doesn't compile */
 181         TP_printk("%d", 0)
 182 );
 183
 184 TRACE_EVENT(iwlwifi_dev_ict_read,
 185         TP_PROTO(const struct device *dev, u32 index, u32 value),
 186         TP_ARGS(dev, index, value),
 187         TP_STRUCT__entry(
 188                 DEV_ENTRY
 189                 __field(u32, index)
 190                 __field(u32, value)
 191         ),
 192         TP_fast_assign(
 193                 DEV_ASSIGN;
 194                 __entry->index = index;
 195                 __entry->value = value;
 196         ),
 197         TP_printk("[%s] read ict[%d] = %#.8x",
 198                   __get_str(dev), __entry->index, __entry->value)
 199 );
 200
 201 #undef TRACE_SYSTEM
 202 #define TRACE_SYSTEM iwlwifi_ucode
 203
 204 TRACE_EVENT(iwlwifi_dev_ucode_cont_event,
 205         TP_PROTO(const struct device *dev, u32 time, u32 data, u32 ev),
 206         TP_ARGS(dev, time, data, ev),
 207         TP_STRUCT__entry(
 208                 DEV_ENTRY
 209
 210                 __field(u32, time)
 211                 __field(u32, data)
 212                 __field(u32, ev)
 213         ),
 214         TP_fast_assign(
 215                 DEV_ASSIGN;
 216                 __entry->time = time;
 217                 __entry->data = data;
 218                 __entry->ev = ev;
 219         ),
 220         TP_printk("[%s] EVT_LOGT:%010u:0x%08x:%04u",
 221                   __get_str(dev), __entry->time, __entry->data, __entry->ev)
 222 );
 223
 224 TRACE_EVENT(iwlwifi_dev_ucode_wrap_event,
 225         TP_PROTO(const struct device *dev, u32 wraps, u32 n_entry, u32 p_entry),
 226         TP_ARGS(dev, wraps, n_entry, p_entry),
 227         TP_STRUCT__entry(
 228                 DEV_ENTRY
 229
 230                 __field(u32, wraps)
 231                 __field(u32, n_entry)
 232                 __field(u32, p_entry)
 233         ),
 234         TP_fast_assign(
 235                 DEV_ASSIGN;
 236                 __entry->wraps = wraps;
 237                 __entry->n_entry = n_entry;
 238                 __entry->p_entry = p_entry;
 239         ),
 240         TP_printk("[%s] wraps=#%02d n=0x%X p=0x%X",
 241                   __get_str(dev), __entry->wraps, __entry->n_entry,
 242                   __entry->p_entry)
 243 );
 244
 245 #undef TRACE_SYSTEM
 246 #define TRACE_SYSTEM iwlwifi_msg
 247
 248 #define MAX_MSG_LEN     110
 249
 250 DECLARE_EVENT_CLASS(iwlwifi_msg_event,
 251         TP_PROTO(struct va_format *vaf),
 252         TP_ARGS(vaf),
 253         TP_STRUCT__entry(
 254                 __dynamic_array(char, msg, MAX_MSG_LEN)
 255         ),
 256         TP_fast_assign(
 257                 WARN_ON_ONCE(vsnprintf(__get_dynamic_array(msg),
 258                                        MAX_MSG_LEN, vaf->fmt,
 259                                        *vaf->va) >= MAX_MSG_LEN);
 260         ),
 261         TP_printk("%s", __get_str(msg))
 262 );
 263
 264 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_err,
 265         TP_PROTO(struct va_format *vaf),
 266         TP_ARGS(vaf)
 267 );
 268
 269 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_warn,
 270         TP_PROTO(struct va_format *vaf),
 271         TP_ARGS(vaf)
 272 );
 273
 274 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_info,
 275         TP_PROTO(struct va_format *vaf),
 276         TP_ARGS(vaf)
 277 );
 278
 279 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_crit,
 280         TP_PROTO(struct va_format *vaf),
 281         TP_ARGS(vaf)
 282 );
 283
 284 TRACE_EVENT(iwlwifi_dbg,
 285         TP_PROTO(u32 level, bool in_interrupt, const char *function,
 286                  struct va_format *vaf),
 287         TP_ARGS(level, in_interrupt, function, vaf),
 288         TP_STRUCT__entry(
 289                 __field(u32, level)
 290                 __field(u8, in_interrupt)
 291                 __string(function, function)
 292                 __dynamic_array(char, msg, MAX_MSG_LEN)
 293         ),
 294         TP_fast_assign(
 295                 __entry->level = level;
 296                 __entry->in_interrupt = in_interrupt;
 297                 __assign_str(function, function);
 298                 WARN_ON_ONCE(vsnprintf(__get_dynamic_array(msg),
 299                                        MAX_MSG_LEN, vaf->fmt,
 300                                        *vaf->va) >= MAX_MSG_LEN);
 301         ),
 302         TP_printk("%s", __get_str(msg))
 303 );
 304
 305 #undef TRACE_SYSTEM
 306 #define TRACE_SYSTEM iwlwifi_data
 307
 308 TRACE_EVENT(iwlwifi_dev_tx_data,
 309         TP_PROTO(const struct device *dev,
 310                  struct sk_buff *skb,
 311                  void *data, size_t data_len),
 312         TP_ARGS(dev, skb, data, data_len),
 313         TP_STRUCT__entry(
 314                 DEV_ENTRY
 315
 316                 __dynamic_array(u8, data, iwl_trace_data(skb) ? data_len : 0)
 317         ),
 318         TP_fast_assign(
 319                 DEV_ASSIGN;
 320                 if (iwl_trace_data(skb))
 321                         memcpy(__get_dynamic_array(data), data, data_len);
 322         ),
 323         TP_printk("[%s] TX frame data", __get_str(dev))
 324 );
 325
 326 TRACE_EVENT(iwlwifi_dev_rx_data,
 327         TP_PROTO(const struct device *dev,
 328                  const struct iwl_trans *trans,
 329                  void *rxbuf, size_t len),
 330         TP_ARGS(dev, trans, rxbuf, len),
 331         TP_STRUCT__entry(
 332                 DEV_ENTRY
 333
 334                 __dynamic_array(u8, data,
 335                                 len - iwl_rx_trace_len(trans, rxbuf, len))
 336         ),
 337         TP_fast_assign(
 338                 size_t offs = iwl_rx_trace_len(trans, rxbuf, len);
 339                 DEV_ASSIGN;
 340                 if (offs < len)
 341                         memcpy(__get_dynamic_array(data),
 342                                ((u8 *)rxbuf) + offs, len - offs);
 343         ),
 344         TP_printk("[%s] RX frame data", __get_str(dev))
 345 );
 346
 347 #undef TRACE_SYSTEM
 348 #define TRACE_SYSTEM iwlwifi
 349
 350 TRACE_EVENT(iwlwifi_dev_hcmd,
 351         TP_PROTO(const struct device *dev,
 352                  struct iwl_host_cmd *cmd, u16 total_size,
 353                  struct iwl_cmd_header *hdr),
 354         TP_ARGS(dev, cmd, total_size, hdr),
 355         TP_STRUCT__entry(
 356                 DEV_ENTRY
 357                 __dynamic_array(u8, hcmd, total_size)
 358                 __field(u32, flags)
 359         ),
 360         TP_fast_assign(
 361                 int i, offset = sizeof(*hdr);
 362
 363                 DEV_ASSIGN;
 364                 __entry->flags = cmd->flags;
 365                 memcpy(__get_dynamic_array(hcmd), hdr, sizeof(*hdr));
 366
 367                 for (i = 0; i < IWL_MAX_CMD_TBS_PER_TFD; i++) {
 368                         if (!cmd->len[i])
 369                                 continue;
 370                         memcpy((u8 *)__get_dynamic_array(hcmd) + offset,
 371                                cmd->data[i], cmd->len[i]);
 372                         offset += cmd->len[i];
 373                 }
 374         ),
 375         TP_printk("[%s] hcmd %#.2x (%ssync)",
 376                   __get_str(dev), ((u8 *)__get_dynamic_array(hcmd))[0],
 377                   __entry->flags & CMD_ASYNC ? "a" : "")
 378 );
 379
 380 TRACE_EVENT(iwlwifi_dev_rx,
 381         TP_PROTO(const struct device *dev, const struct iwl_trans *trans,
 382                  void *rxbuf, size_t len),
 383         TP_ARGS(dev, trans, rxbuf, len),
 384         TP_STRUCT__entry(
 385                 DEV_ENTRY
 386                 __dynamic_array(u8, rxbuf, iwl_rx_trace_len(trans, rxbuf, len))
 387         ),
 388         TP_fast_assign(
 389                 DEV_ASSIGN;
 390                 memcpy(__get_dynamic_array(rxbuf), rxbuf,
 391                        iwl_rx_trace_len(trans, rxbuf, len));
 392         ),
 393         TP_printk("[%s] RX cmd %#.2x",
 394                   __get_str(dev), ((u8 *)__get_dynamic_array(rxbuf))[4])
 395 );
 396
 397 TRACE_EVENT(iwlwifi_dev_tx,
 398         TP_PROTO(const struct device *dev, struct sk_buff *skb,
 399                  void *tfd, size_t tfdlen,
 400                  void *buf0, size_t buf0_len,
 401                  void *buf1, size_t buf1_len),
 402         TP_ARGS(dev, skb, tfd, tfdlen, buf0, buf0_len, buf1, buf1_len),
 403         TP_STRUCT__entry(
 404                 DEV_ENTRY
 405
 406                 __field(size_t, framelen)
 407                 __dynamic_array(u8, tfd, tfdlen)
 408
 409                 /*
 410                  * Do not insert between or below these items,
 411                  * we want to keep the frame together (except
 412                  * for the possible padding).
 413                  */
 414                 __dynamic_array(u8, buf0, buf0_len)
 415                 __dynamic_array(u8, buf1, iwl_trace_data(skb) ? 0 : buf1_len)
 416         ),
 417         TP_fast_assign(
 418                 DEV_ASSIGN;
 419                 __entry->framelen = buf0_len + buf1_len;
 420                 memcpy(__get_dynamic_array(tfd), tfd, tfdlen);
 421                 memcpy(__get_dynamic_array(buf0), buf0, buf0_len);
 422                 if (!iwl_trace_data(skb))
 423                         memcpy(__get_dynamic_array(buf1), buf1, buf1_len);
 424         ),
 425         TP_printk("[%s] TX %.2x (%zu bytes)",
 426                   __get_str(dev), ((u8 *)__get_dynamic_array(buf0))[0],
 427                   __entry->framelen)
 428 );
 429
 430 TRACE_EVENT(iwlwifi_dev_ucode_error,
 431         TP_PROTO(const struct device *dev, u32 desc, u32 tsf_low,
 432                  u32 data1, u32 data2, u32 line, u32 blink1,
 433                  u32 blink2, u32 ilink1, u32 ilink2, u32 bcon_time,
 434                  u32 gp1, u32 gp2, u32 gp3, u32 ucode_ver, u32 hw_ver,
 435                  u32 brd_ver),
 436         TP_ARGS(dev, desc, tsf_low, data1, data2, line,
 437                 blink1, blink2, ilink1, ilink2, bcon_time, gp1, gp2,
 438                 gp3, ucode_ver, hw_ver, brd_ver),
 439         TP_STRUCT__entry(
 440                 DEV_ENTRY
 441                 __field(u32, desc)
 442                 __field(u32, tsf_low)
 443                 __field(u32, data1)
 444                 __field(u32, data2)
 445                 __field(u32, line)
 446                 __field(u32, blink1)
 447                 __field(u32, blink2)
 448                 __field(u32, ilink1)
 449                 __field(u32, ilink2)
 450                 __field(u32, bcon_time)
 451                 __field(u32, gp1)
 452                 __field(u32, gp2)
 453                 __field(u32, gp3)
 454                 __field(u32, ucode_ver)
 455                 __field(u32, hw_ver)
 456                 __field(u32, brd_ver)
 457         ),
 458         TP_fast_assign(
 459                 DEV_ASSIGN;
 460                 __entry->desc = desc;
 461                 __entry->tsf_low = tsf_low;
 462                 __entry->data1 = data1;
 463                 __entry->data2 = data2;
 464                 __entry->line = line;
 465                 __entry->blink1 = blink1;
 466                 __entry->blink2 = blink2;
 467                 __entry->ilink1 = ilink1;
 468                 __entry->ilink2 = ilink2;
 469                 __entry->bcon_time = bcon_time;
 470                 __entry->gp1 = gp1;
 471                 __entry->gp2 = gp2;
 472                 __entry->gp3 = gp3;
 473                 __entry->ucode_ver = ucode_ver;
 474                 __entry->hw_ver = hw_ver;
 475                 __entry->brd_ver = brd_ver;
 476         ),
 477         TP_printk("[%s] #%02d %010u data 0x%08X 0x%08X line %u, "
 478                   "blink 0x%05X 0x%05X ilink 0x%05X 0x%05X "
 479                   "bcon_tm %010u gp 0x%08X 0x%08X 0x%08X uCode 0x%08X "
 480                   "hw 0x%08X brd 0x%08X",
 481                   __get_str(dev), __entry->desc, __entry->tsf_low,
 482                   __entry->data1,
 483                   __entry->data2, __entry->line, __entry->blink1,
 484                   __entry->blink2, __entry->ilink1, __entry->ilink2,
 485                   __entry->bcon_time, __entry->gp1, __entry->gp2,
 486                   __entry->gp3, __entry->ucode_ver, __entry->hw_ver,
 487                   __entry->brd_ver)
 488 );
 489
 490 TRACE_EVENT(iwlwifi_dev_ucode_event,
 491         TP_PROTO(const struct device *dev, u32 time, u32 data, u32 ev),
 492         TP_ARGS(dev, time, data, ev),
 493         TP_STRUCT__entry(
 494                 DEV_ENTRY
 495
 496                 __field(u32, time)
 497                 __field(u32, data)
 498                 __field(u32, ev)
 499         ),
 500         TP_fast_assign(
 501                 DEV_ASSIGN;
 502                 __entry->time = time;
 503                 __entry->data = data;
 504                 __entry->ev = ev;
 505         ),
 506         TP_printk("[%s] EVT_LOGT:%010u:0x%08x:%04u",
 507                   __get_str(dev), __entry->time, __entry->data, __entry->ev)
 508 );
 509 #endif /* __IWLWIFI_DEVICE_TRACE */
 510
 511 #undef TRACE_INCLUDE_PATH
 512 #define TRACE_INCLUDE_PATH .
 513 #undef TRACE_INCLUDE_FILE
 514 #define TRACE_INCLUDE_FILE iwl-devtrace
 515 #include <trace/define_trace.h>