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