net/wireless/trace.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM cfg80211
   4
   5 #if !defined(__RDEV_OPS_TRACE) || defined(TRACE_HEADER_MULTI_READ)
   6 #define __RDEV_OPS_TRACE
   7
   8 #include <linux/tracepoint.h>
   9
  10 #include <linux/rtnetlink.h>
  11 #include <linux/etherdevice.h>
  12 #include <net/cfg80211.h>
  13 #include "core.h"
  14
  15 #define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN)
  16 #define MAC_ASSIGN(entry_mac, given_mac) do {                        \
  17         if (given_mac)                                               \
  18                 memcpy(__entry->entry_mac, given_mac, ETH_ALEN);     \
  19         else                                                         \
  20                 eth_zero_addr(__entry->entry_mac);                   \
  21         } while (0)
  22 #define MAC_PR_FMT "%pM"
  23 #define MAC_PR_ARG(entry_mac) (__entry->entry_mac)
  24
  25 #define MAXNAME         32
  26 #define WIPHY_ENTRY     __array(char, wiphy_name, 32)
  27 #define WIPHY_ASSIGN    strlcpy(__entry->wiphy_name, wiphy_name(wiphy), MAXNAME)
  28 #define WIPHY_PR_FMT    "%s"
  29 #define WIPHY_PR_ARG    __entry->wiphy_name
  30
  31 #define WDEV_ENTRY      __field(u32, id)
  32 #define WDEV_ASSIGN     (__entry->id) = (!IS_ERR_OR_NULL(wdev)  \
  33                                          ? wdev->identifier : 0)
  34 #define WDEV_PR_FMT     "wdev(%u)"
  35 #define WDEV_PR_ARG     (__entry->id)
  36
  37 #define NETDEV_ENTRY    __array(char, name, IFNAMSIZ) \
  38                         __field(int, ifindex)
  39 #define NETDEV_ASSIGN                                          \
  40         do {                                                   \
  41                 memcpy(__entry->name, netdev->name, IFNAMSIZ); \
  42                 (__entry->ifindex) = (netdev->ifindex);        \
  43         } while (0)
  44 #define NETDEV_PR_FMT   "netdev:%s(%d)"
  45 #define NETDEV_PR_ARG   __entry->name, __entry->ifindex
  46
  47 #define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout)                 \
  48                        __field(u16, dot11MeshConfirmTimeout)               \
  49                        __field(u16, dot11MeshHoldingTimeout)               \
  50                        __field(u16, dot11MeshMaxPeerLinks)                 \
  51                        __field(u8, dot11MeshMaxRetries)                    \
  52                        __field(u8, dot11MeshTTL)                           \
  53                        __field(u8, element_ttl)                            \
  54                        __field(bool, auto_open_plinks)                     \
  55                        __field(u32, dot11MeshNbrOffsetMaxNeighbor)         \
  56                        __field(u8, dot11MeshHWMPmaxPREQretries)            \
  57                        __field(u32, path_refresh_time)                     \
  58                        __field(u32, dot11MeshHWMPactivePathTimeout)        \
  59                        __field(u16, min_discovery_timeout)                 \
  60                        __field(u16, dot11MeshHWMPpreqMinInterval)          \
  61                        __field(u16, dot11MeshHWMPperrMinInterval)          \
  62                        __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \
  63                        __field(u8, dot11MeshHWMPRootMode)                  \
  64                        __field(u16, dot11MeshHWMPRannInterval)             \
  65                        __field(bool, dot11MeshGateAnnouncementProtocol)    \
  66                        __field(bool, dot11MeshForwarding)                  \
  67                        __field(s32, rssi_threshold)                        \
  68                        __field(u16, ht_opmode)                             \
  69                        __field(u32, dot11MeshHWMPactivePathToRootTimeout)  \
  70                        __field(u16, dot11MeshHWMProotInterval)             \
  71                        __field(u16, dot11MeshHWMPconfirmationInterval)     \
  72                        __field(bool, dot11MeshNolearn)
  73 #define MESH_CFG_ASSIGN                                                       \
  74         do {                                                                  \
  75                 __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \
  76                 __entry->dot11MeshConfirmTimeout =                            \
  77                                 conf->dot11MeshConfirmTimeout;                \
  78                 __entry->dot11MeshHoldingTimeout =                            \
  79                                 conf->dot11MeshHoldingTimeout;                \
  80                 __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \
  81                 __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries;     \
  82                 __entry->dot11MeshTTL = conf->dot11MeshTTL;                   \
  83                 __entry->element_ttl = conf->element_ttl;                     \
  84                 __entry->auto_open_plinks = conf->auto_open_plinks;           \
  85                 __entry->dot11MeshNbrOffsetMaxNeighbor =                      \
  86                                 conf->dot11MeshNbrOffsetMaxNeighbor;          \
  87                 __entry->dot11MeshHWMPmaxPREQretries =                        \
  88                                 conf->dot11MeshHWMPmaxPREQretries;            \
  89                 __entry->path_refresh_time = conf->path_refresh_time;         \
  90                 __entry->dot11MeshHWMPactivePathTimeout =                     \
  91                                 conf->dot11MeshHWMPactivePathTimeout;         \
  92                 __entry->min_discovery_timeout = conf->min_discovery_timeout; \
  93                 __entry->dot11MeshHWMPpreqMinInterval =                       \
  94                                 conf->dot11MeshHWMPpreqMinInterval;           \
  95                 __entry->dot11MeshHWMPperrMinInterval =                       \
  96                                 conf->dot11MeshHWMPperrMinInterval;           \
  97                 __entry->dot11MeshHWMPnetDiameterTraversalTime =              \
  98                                 conf->dot11MeshHWMPnetDiameterTraversalTime;  \
  99                 __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \
 100                 __entry->dot11MeshHWMPRannInterval =                          \
 101                                 conf->dot11MeshHWMPRannInterval;              \
 102                 __entry->dot11MeshGateAnnouncementProtocol =                  \
 103                                 conf->dot11MeshGateAnnouncementProtocol;      \
 104                 __entry->dot11MeshForwarding = conf->dot11MeshForwarding;     \
 105                 __entry->rssi_threshold = conf->rssi_threshold;               \
 106                 __entry->ht_opmode = conf->ht_opmode;                         \
 107                 __entry->dot11MeshHWMPactivePathToRootTimeout =               \
 108                                 conf->dot11MeshHWMPactivePathToRootTimeout;   \
 109                 __entry->dot11MeshHWMProotInterval =                          \
 110                                 conf->dot11MeshHWMProotInterval;              \
 111                 __entry->dot11MeshHWMPconfirmationInterval =                  \
 112                                 conf->dot11MeshHWMPconfirmationInterval;      \
 113                 __entry->dot11MeshNolearn = conf->dot11MeshNolearn;           \
 114         } while (0)
 115
 116 #define CHAN_ENTRY __field(enum nl80211_band, band) \
 117                    __field(u32, center_freq)            \
 118                    __field(u16, freq_offset)
 119 #define CHAN_ASSIGN(chan)                                         \
 120         do {                                                      \
 121                 if (chan) {                                       \
 122                         __entry->band = chan->band;               \
 123                         __entry->center_freq = chan->center_freq; \
 124                         __entry->freq_offset = chan->freq_offset; \
 125                 } else {                                          \
 126                         __entry->band = 0;                        \
 127                         __entry->center_freq = 0;                 \
 128                         __entry->freq_offset = 0;                 \
 129                 }                                                 \
 130         } while (0)
 131 #define CHAN_PR_FMT "band: %d, freq: %u.%03u"
 132 #define CHAN_PR_ARG __entry->band, __entry->center_freq, __entry->freq_offset
 133
 134 #define CHAN_DEF_ENTRY __field(enum nl80211_band, band)         \
 135                        __field(u32, control_freq)                       \
 136                        __field(u32, freq_offset)                        \
 137                        __field(u32, width)                              \
 138                        __field(u32, center_freq1)                       \
 139                        __field(u32, freq1_offset)                       \
 140                        __field(u32, center_freq2)
 141 #define CHAN_DEF_ASSIGN(chandef)                                        \
 142         do {                                                            \
 143                 if ((chandef) && (chandef)->chan) {                     \
 144                         __entry->band = (chandef)->chan->band;          \
 145                         __entry->control_freq =                         \
 146                                 (chandef)->chan->center_freq;           \
 147                         __entry->freq_offset =                          \
 148                                 (chandef)->chan->freq_offset;           \
 149                         __entry->width = (chandef)->width;              \
 150                         __entry->center_freq1 = (chandef)->center_freq1;\
 151                         __entry->freq1_offset = (chandef)->freq1_offset;\
 152                         __entry->center_freq2 = (chandef)->center_freq2;\
 153                 } else {                                                \
 154                         __entry->band = 0;                              \
 155                         __entry->control_freq = 0;                      \
 156                         __entry->freq_offset = 0;                       \
 157                         __entry->width = 0;                             \
 158                         __entry->center_freq1 = 0;                      \
 159                         __entry->freq1_offset = 0;                      \
 160                         __entry->center_freq2 = 0;                      \
 161                 }                                                       \
 162         } while (0)
 163 #define CHAN_DEF_PR_FMT                                                 \
 164         "band: %d, control freq: %u.%03u, width: %d, cf1: %u.%03u, cf2: %u"
 165 #define CHAN_DEF_PR_ARG __entry->band, __entry->control_freq,           \
 166                         __entry->freq_offset, __entry->width,           \
 167                         __entry->center_freq1, __entry->freq1_offset,   \
 168                         __entry->center_freq2
 169
 170 #define FILS_AAD_ASSIGN(fa)                                             \
 171         do {                                                            \
 172                 if (fa) {                                               \
 173                         ether_addr_copy(__entry->macaddr, fa->macaddr); \
 174                         __entry->kek_len = fa->kek_len;                 \
 175                 } else {                                                \
 176                         eth_zero_addr(__entry->macaddr);                \
 177                         __entry->kek_len = 0;                           \
 178                 }                                                       \
 179         } while (0)
 180 #define FILS_AAD_PR_FMT                                                 \
 181         "macaddr: %pM, kek_len: %d"
 182
 183 #define SINFO_ENTRY __field(int, generation)        \
 184                     __field(u32, connected_time)    \
 185                     __field(u32, inactive_time)     \
 186                     __field(u32, rx_bytes)          \
 187                     __field(u32, tx_bytes)          \
 188                     __field(u32, rx_packets)        \
 189                     __field(u32, tx_packets)        \
 190                     __field(u32, tx_retries)        \
 191                     __field(u32, tx_failed)         \
 192                     __field(u32, rx_dropped_misc)   \
 193                     __field(u32, beacon_loss_count) \
 194                     __field(u16, llid)              \
 195                     __field(u16, plid)              \
 196                     __field(u8, plink_state)
 197 #define SINFO_ASSIGN                                                   \
 198         do {                                                           \
 199                 __entry->generation = sinfo->generation;               \
 200                 __entry->connected_time = sinfo->connected_time;       \
 201                 __entry->inactive_time = sinfo->inactive_time;         \
 202                 __entry->rx_bytes = sinfo->rx_bytes;                   \
 203                 __entry->tx_bytes = sinfo->tx_bytes;                   \
 204                 __entry->rx_packets = sinfo->rx_packets;               \
 205                 __entry->tx_packets = sinfo->tx_packets;               \
 206                 __entry->tx_retries = sinfo->tx_retries;               \
 207                 __entry->tx_failed = sinfo->tx_failed;                 \
 208                 __entry->rx_dropped_misc = sinfo->rx_dropped_misc;     \
 209                 __entry->beacon_loss_count = sinfo->beacon_loss_count; \
 210                 __entry->llid = sinfo->llid;                           \
 211                 __entry->plid = sinfo->plid;                           \
 212                 __entry->plink_state = sinfo->plink_state;             \
 213         } while (0)
 214
 215 #define BOOL_TO_STR(bo) (bo) ? "true" : "false"
 216
 217 #define QOS_MAP_ENTRY __field(u8, num_des)                      \
 218                       __array(u8, dscp_exception,               \
 219                               2 * IEEE80211_QOS_MAP_MAX_EX)     \
 220                       __array(u8, up, IEEE80211_QOS_MAP_LEN_MIN)
 221 #define QOS_MAP_ASSIGN(qos_map)                                 \
 222         do {                                                    \
 223                 if ((qos_map)) {                                \
 224                         __entry->num_des = (qos_map)->num_des;  \
 225                         memcpy(__entry->dscp_exception,         \
 226                                &(qos_map)->dscp_exception,      \
 227                                2 * IEEE80211_QOS_MAP_MAX_EX);   \
 228                         memcpy(__entry->up, &(qos_map)->up,     \
 229                                IEEE80211_QOS_MAP_LEN_MIN);      \
 230                 } else {                                        \
 231                         __entry->num_des = 0;                   \
 232                         memset(__entry->dscp_exception, 0,      \
 233                                2 * IEEE80211_QOS_MAP_MAX_EX);   \
 234                         memset(__entry->up, 0,                  \
 235                                IEEE80211_QOS_MAP_LEN_MIN);      \
 236                 }                                               \
 237         } while (0)
 238
 239 /*************************************************************
 240  *                      rdev->ops traces                     *
 241  *************************************************************/
 242
 243 TRACE_EVENT(rdev_suspend,
 244         TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow),
 245         TP_ARGS(wiphy, wow),
 246         TP_STRUCT__entry(
 247                 WIPHY_ENTRY
 248                 __field(bool, any)
 249                 __field(bool, disconnect)
 250                 __field(bool, magic_pkt)
 251                 __field(bool, gtk_rekey_failure)
 252                 __field(bool, eap_identity_req)
 253                 __field(bool, four_way_handshake)
 254                 __field(bool, rfkill_release)
 255                 __field(bool, valid_wow)
 256         ),
 257         TP_fast_assign(
 258                 WIPHY_ASSIGN;
 259                 if (wow) {
 260                         __entry->any = wow->any;
 261                         __entry->disconnect = wow->disconnect;
 262                         __entry->magic_pkt = wow->magic_pkt;
 263                         __entry->gtk_rekey_failure = wow->gtk_rekey_failure;
 264                         __entry->eap_identity_req = wow->eap_identity_req;
 265                         __entry->four_way_handshake = wow->four_way_handshake;
 266                         __entry->rfkill_release = wow->rfkill_release;
 267                         __entry->valid_wow = true;
 268                 } else {
 269                         __entry->valid_wow = false;
 270                 }
 271         ),
 272         TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, "
 273                   "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, "
 274                   "four way handshake: %d, rfkill release: %d.",
 275                   WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)",
 276                   __entry->any, __entry->disconnect, __entry->magic_pkt,
 277                   __entry->gtk_rekey_failure, __entry->eap_identity_req,
 278                   __entry->four_way_handshake, __entry->rfkill_release)
 279 );
 280
 281 TRACE_EVENT(rdev_return_int,
 282         TP_PROTO(struct wiphy *wiphy, int ret),
 283         TP_ARGS(wiphy, ret),
 284         TP_STRUCT__entry(
 285                 WIPHY_ENTRY
 286                 __field(int, ret)
 287         ),
 288         TP_fast_assign(
 289                 WIPHY_ASSIGN;
 290                 __entry->ret = ret;
 291         ),
 292         TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret)
 293 );
 294
 295 TRACE_EVENT(rdev_scan,
 296         TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request),
 297         TP_ARGS(wiphy, request),
 298         TP_STRUCT__entry(
 299                 WIPHY_ENTRY
 300         ),
 301         TP_fast_assign(
 302                 WIPHY_ASSIGN;
 303         ),
 304         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
 305 );
 306
 307 DECLARE_EVENT_CLASS(wiphy_only_evt,
 308         TP_PROTO(struct wiphy *wiphy),
 309         TP_ARGS(wiphy),
 310         TP_STRUCT__entry(
 311                 WIPHY_ENTRY
 312         ),
 313         TP_fast_assign(
 314                 WIPHY_ASSIGN;
 315         ),
 316         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
 317 );
 318
 319 DEFINE_EVENT(wiphy_only_evt, rdev_resume,
 320         TP_PROTO(struct wiphy *wiphy),
 321         TP_ARGS(wiphy)
 322 );
 323
 324 DEFINE_EVENT(wiphy_only_evt, rdev_return_void,
 325         TP_PROTO(struct wiphy *wiphy),
 326         TP_ARGS(wiphy)
 327 );
 328
 329 DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna,
 330         TP_PROTO(struct wiphy *wiphy),
 331         TP_ARGS(wiphy)
 332 );
 333
 334 DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll,
 335         TP_PROTO(struct wiphy *wiphy),
 336         TP_ARGS(wiphy)
 337 );
 338
 339 DECLARE_EVENT_CLASS(wiphy_enabled_evt,
 340         TP_PROTO(struct wiphy *wiphy, bool enabled),
 341         TP_ARGS(wiphy, enabled),
 342         TP_STRUCT__entry(
 343                 WIPHY_ENTRY
 344                 __field(bool, enabled)
 345         ),
 346         TP_fast_assign(
 347                 WIPHY_ASSIGN;
 348                 __entry->enabled = enabled;
 349         ),
 350         TP_printk(WIPHY_PR_FMT ", %senabled ",
 351                   WIPHY_PR_ARG, __entry->enabled ? "" : "not ")
 352 );
 353
 354 DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup,
 355         TP_PROTO(struct wiphy *wiphy, bool enabled),
 356         TP_ARGS(wiphy, enabled)
 357 );
 358
 359 TRACE_EVENT(rdev_add_virtual_intf,
 360         TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type),
 361         TP_ARGS(wiphy, name, type),
 362         TP_STRUCT__entry(
 363                 WIPHY_ENTRY
 364                 __string(vir_intf_name, name ? name : "<noname>")
 365                 __field(enum nl80211_iftype, type)
 366         ),
 367         TP_fast_assign(
 368                 WIPHY_ASSIGN;
 369                 __assign_str(vir_intf_name, name ? name : "<noname>");
 370                 __entry->type = type;
 371         ),
 372         TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d",
 373                   WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type)
 374 );
 375
 376 DECLARE_EVENT_CLASS(wiphy_wdev_evt,
 377         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
 378         TP_ARGS(wiphy, wdev),
 379         TP_STRUCT__entry(
 380                 WIPHY_ENTRY
 381                 WDEV_ENTRY
 382         ),
 383         TP_fast_assign(
 384                 WIPHY_ASSIGN;
 385                 WDEV_ASSIGN;
 386         ),
 387         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
 388 );
 389
 390 DECLARE_EVENT_CLASS(wiphy_wdev_cookie_evt,
 391         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
 392         TP_ARGS(wiphy, wdev, cookie),
 393         TP_STRUCT__entry(
 394                 WIPHY_ENTRY
 395                 WDEV_ENTRY
 396                 __field(u64, cookie)
 397         ),
 398         TP_fast_assign(
 399                 WIPHY_ASSIGN;
 400                 WDEV_ASSIGN;
 401                 __entry->cookie = cookie;
 402         ),
 403         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %lld",
 404                   WIPHY_PR_ARG, WDEV_PR_ARG,
 405                   (unsigned long long)__entry->cookie)
 406 );
 407
 408 DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev,
 409         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
 410         TP_ARGS(wiphy, wdev)
 411 );
 412
 413 DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf,
 414         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
 415         TP_ARGS(wiphy, wdev)
 416 );
 417
 418 TRACE_EVENT(rdev_change_virtual_intf,
 419         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 420                  enum nl80211_iftype type),
 421         TP_ARGS(wiphy, netdev, type),
 422         TP_STRUCT__entry(
 423                 WIPHY_ENTRY
 424                 NETDEV_ENTRY
 425                 __field(enum nl80211_iftype, type)
 426         ),
 427         TP_fast_assign(
 428                 WIPHY_ASSIGN;
 429                 NETDEV_ASSIGN;
 430                 __entry->type = type;
 431         ),
 432         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", type: %d",
 433                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type)
 434 );
 435
 436 DECLARE_EVENT_CLASS(key_handle,
 437         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 438                  bool pairwise, const u8 *mac_addr),
 439         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr),
 440         TP_STRUCT__entry(
 441                 WIPHY_ENTRY
 442                 NETDEV_ENTRY
 443                 MAC_ENTRY(mac_addr)
 444                 __field(u8, key_index)
 445                 __field(bool, pairwise)
 446         ),
 447         TP_fast_assign(
 448                 WIPHY_ASSIGN;
 449                 NETDEV_ASSIGN;
 450                 MAC_ASSIGN(mac_addr, mac_addr);
 451                 __entry->key_index = key_index;
 452                 __entry->pairwise = pairwise;
 453         ),
 454         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key_index: %u, pairwise: %s, mac addr: " MAC_PR_FMT,
 455                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
 456                   BOOL_TO_STR(__entry->pairwise), MAC_PR_ARG(mac_addr))
 457 );
 458
 459 DEFINE_EVENT(key_handle, rdev_get_key,
 460         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 461                  bool pairwise, const u8 *mac_addr),
 462         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
 463 );
 464
 465 DEFINE_EVENT(key_handle, rdev_del_key,
 466         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 467                  bool pairwise, const u8 *mac_addr),
 468         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
 469 );
 470
 471 TRACE_EVENT(rdev_add_key,
 472         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 473                  bool pairwise, const u8 *mac_addr, u8 mode),
 474         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr, mode),
 475         TP_STRUCT__entry(
 476                 WIPHY_ENTRY
 477                 NETDEV_ENTRY
 478                 MAC_ENTRY(mac_addr)
 479                 __field(u8, key_index)
 480                 __field(bool, pairwise)
 481                 __field(u8, mode)
 482         ),
 483         TP_fast_assign(
 484                 WIPHY_ASSIGN;
 485                 NETDEV_ASSIGN;
 486                 MAC_ASSIGN(mac_addr, mac_addr);
 487                 __entry->key_index = key_index;
 488                 __entry->pairwise = pairwise;
 489                 __entry->mode = mode;
 490         ),
 491         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key_index: %u, "
 492                   "mode: %u, pairwise: %s, mac addr: " MAC_PR_FMT,
 493                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
 494                   __entry->mode, BOOL_TO_STR(__entry->pairwise),
 495                   MAC_PR_ARG(mac_addr))
 496 );
 497
 498 TRACE_EVENT(rdev_set_default_key,
 499         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
 500                  bool unicast, bool multicast),
 501         TP_ARGS(wiphy, netdev, key_index, unicast, multicast),
 502         TP_STRUCT__entry(
 503                 WIPHY_ENTRY
 504                 NETDEV_ENTRY
 505                 __field(u8, key_index)
 506                 __field(bool, unicast)
 507                 __field(bool, multicast)
 508         ),
 509         TP_fast_assign(
 510                 WIPHY_ASSIGN;
 511                 NETDEV_ASSIGN;
 512                 __entry->key_index = key_index;
 513                 __entry->unicast = unicast;
 514                 __entry->multicast = multicast;
 515         ),
 516         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key index: %u, unicast: %s, multicast: %s",
 517                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
 518                   BOOL_TO_STR(__entry->unicast),
 519                   BOOL_TO_STR(__entry->multicast))
 520 );
 521
 522 TRACE_EVENT(rdev_set_default_mgmt_key,
 523         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index),
 524         TP_ARGS(wiphy, netdev, key_index),
 525         TP_STRUCT__entry(
 526                 WIPHY_ENTRY
 527                 NETDEV_ENTRY
 528                 __field(u8, key_index)
 529         ),
 530         TP_fast_assign(
 531                 WIPHY_ASSIGN;
 532                 NETDEV_ASSIGN;
 533                 __entry->key_index = key_index;
 534         ),
 535         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key index: %u",
 536                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index)
 537 );
 538
 539 TRACE_EVENT(rdev_set_default_beacon_key,
 540         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index),
 541         TP_ARGS(wiphy, netdev, key_index),
 542         TP_STRUCT__entry(
 543                 WIPHY_ENTRY
 544                 NETDEV_ENTRY
 545                 __field(u8, key_index)
 546         ),
 547         TP_fast_assign(
 548                 WIPHY_ASSIGN;
 549                 NETDEV_ASSIGN;
 550                 __entry->key_index = key_index;
 551         ),
 552         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key index: %u",
 553                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index)
 554 );
 555
 556 TRACE_EVENT(rdev_start_ap,
 557         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 558                  struct cfg80211_ap_settings *settings),
 559         TP_ARGS(wiphy, netdev, settings),
 560         TP_STRUCT__entry(
 561                 WIPHY_ENTRY
 562                 NETDEV_ENTRY
 563                 CHAN_DEF_ENTRY
 564                 __field(int, beacon_interval)
 565                 __field(int, dtim_period)
 566                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
 567                 __field(enum nl80211_hidden_ssid, hidden_ssid)
 568                 __field(u32, wpa_ver)
 569                 __field(bool, privacy)
 570                 __field(enum nl80211_auth_type, auth_type)
 571                 __field(int, inactivity_timeout)
 572         ),
 573         TP_fast_assign(
 574                 WIPHY_ASSIGN;
 575                 NETDEV_ASSIGN;
 576                 CHAN_DEF_ASSIGN(&settings->chandef);
 577                 __entry->beacon_interval = settings->beacon_interval;
 578                 __entry->dtim_period = settings->dtim_period;
 579                 __entry->hidden_ssid = settings->hidden_ssid;
 580                 __entry->wpa_ver = settings->crypto.wpa_versions;
 581                 __entry->privacy = settings->privacy;
 582                 __entry->auth_type = settings->auth_type;
 583                 __entry->inactivity_timeout = settings->inactivity_timeout;
 584                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
 585                 memcpy(__entry->ssid, settings->ssid, settings->ssid_len);
 586         ),
 587         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", AP settings - ssid: %s, "
 588                   CHAN_DEF_PR_FMT ", beacon interval: %d, dtim period: %d, "
 589                   "hidden ssid: %d, wpa versions: %u, privacy: %s, "
 590                   "auth type: %d, inactivity timeout: %d",
 591                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_DEF_PR_ARG,
 592                   __entry->beacon_interval, __entry->dtim_period,
 593                   __entry->hidden_ssid, __entry->wpa_ver,
 594                   BOOL_TO_STR(__entry->privacy), __entry->auth_type,
 595                   __entry->inactivity_timeout)
 596 );
 597
 598 TRACE_EVENT(rdev_change_beacon,
 599         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 600                  struct cfg80211_beacon_data *info),
 601         TP_ARGS(wiphy, netdev, info),
 602         TP_STRUCT__entry(
 603                 WIPHY_ENTRY
 604                 NETDEV_ENTRY
 605                 __dynamic_array(u8, head, info ? info->head_len : 0)
 606                 __dynamic_array(u8, tail, info ? info->tail_len : 0)
 607                 __dynamic_array(u8, beacon_ies, info ? info->beacon_ies_len : 0)
 608                 __dynamic_array(u8, proberesp_ies,
 609                                 info ? info->proberesp_ies_len : 0)
 610                 __dynamic_array(u8, assocresp_ies,
 611                                 info ? info->assocresp_ies_len : 0)
 612                 __dynamic_array(u8, probe_resp, info ? info->probe_resp_len : 0)
 613         ),
 614         TP_fast_assign(
 615                 WIPHY_ASSIGN;
 616                 NETDEV_ASSIGN;
 617                 if (info) {
 618                         if (info->head)
 619                                 memcpy(__get_dynamic_array(head), info->head,
 620                                        info->head_len);
 621                         if (info->tail)
 622                                 memcpy(__get_dynamic_array(tail), info->tail,
 623                                        info->tail_len);
 624                         if (info->beacon_ies)
 625                                 memcpy(__get_dynamic_array(beacon_ies),
 626                                        info->beacon_ies, info->beacon_ies_len);
 627                         if (info->proberesp_ies)
 628                                 memcpy(__get_dynamic_array(proberesp_ies),
 629                                        info->proberesp_ies,
 630                                        info->proberesp_ies_len);
 631                         if (info->assocresp_ies)
 632                                 memcpy(__get_dynamic_array(assocresp_ies),
 633                                        info->assocresp_ies,
 634                                        info->assocresp_ies_len);
 635                         if (info->probe_resp)
 636                                 memcpy(__get_dynamic_array(probe_resp),
 637                                        info->probe_resp, info->probe_resp_len);
 638                 }
 639         ),
 640         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
 641 );
 642
 643 DECLARE_EVENT_CLASS(wiphy_netdev_evt,
 644         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 645         TP_ARGS(wiphy, netdev),
 646         TP_STRUCT__entry(
 647                 WIPHY_ENTRY
 648                 NETDEV_ENTRY
 649         ),
 650         TP_fast_assign(
 651                 WIPHY_ASSIGN;
 652                 NETDEV_ASSIGN;
 653         ),
 654         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
 655 );
 656
 657 DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap,
 658         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 659         TP_ARGS(wiphy, netdev)
 660 );
 661
 662 DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data,
 663         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 664         TP_ARGS(wiphy, netdev)
 665 );
 666
 667 DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config,
 668         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 669         TP_ARGS(wiphy, netdev)
 670 );
 671
 672 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh,
 673         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 674         TP_ARGS(wiphy, netdev)
 675 );
 676
 677 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss,
 678         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 679         TP_ARGS(wiphy, netdev)
 680 );
 681
 682 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb,
 683         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 684         TP_ARGS(wiphy, netdev)
 685 );
 686
 687 DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa,
 688         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 689         TP_ARGS(wiphy, netdev)
 690 );
 691
 692 DEFINE_EVENT(wiphy_netdev_evt, rdev_end_cac,
 693              TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 694              TP_ARGS(wiphy, netdev)
 695 );
 696
 697 DECLARE_EVENT_CLASS(station_add_change,
 698         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
 699                  struct station_parameters *params),
 700         TP_ARGS(wiphy, netdev, mac, params),
 701         TP_STRUCT__entry(
 702                 WIPHY_ENTRY
 703                 NETDEV_ENTRY
 704                 MAC_ENTRY(sta_mac)
 705                 __field(u32, sta_flags_mask)
 706                 __field(u32, sta_flags_set)
 707                 __field(u32, sta_modify_mask)
 708                 __field(int, listen_interval)
 709                 __field(u16, capability)
 710                 __field(u16, aid)
 711                 __field(u8, plink_action)
 712                 __field(u8, plink_state)
 713                 __field(u8, uapsd_queues)
 714                 __field(u8, max_sp)
 715                 __field(u8, opmode_notif)
 716                 __field(bool, opmode_notif_used)
 717                 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
 718                 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap))
 719                 __array(char, vlan, IFNAMSIZ)
 720                 __dynamic_array(u8, supported_rates,
 721                                 params->supported_rates_len)
 722                 __dynamic_array(u8, ext_capab, params->ext_capab_len)
 723                 __dynamic_array(u8, supported_channels,
 724                                 params->supported_channels_len)
 725                 __dynamic_array(u8, supported_oper_classes,
 726                                 params->supported_oper_classes_len)
 727         ),
 728         TP_fast_assign(
 729                 WIPHY_ASSIGN;
 730                 NETDEV_ASSIGN;
 731                 MAC_ASSIGN(sta_mac, mac);
 732                 __entry->sta_flags_mask = params->sta_flags_mask;
 733                 __entry->sta_flags_set = params->sta_flags_set;
 734                 __entry->sta_modify_mask = params->sta_modify_mask;
 735                 __entry->listen_interval = params->listen_interval;
 736                 __entry->aid = params->aid;
 737                 __entry->plink_action = params->plink_action;
 738                 __entry->plink_state = params->plink_state;
 739                 __entry->uapsd_queues = params->uapsd_queues;
 740                 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
 741                 if (params->ht_capa)
 742                         memcpy(__entry->ht_capa, params->ht_capa,
 743                                sizeof(struct ieee80211_ht_cap));
 744                 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap));
 745                 if (params->vht_capa)
 746                         memcpy(__entry->vht_capa, params->vht_capa,
 747                                sizeof(struct ieee80211_vht_cap));
 748                 memset(__entry->vlan, 0, sizeof(__entry->vlan));
 749                 if (params->vlan)
 750                         memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ);
 751                 if (params->supported_rates && params->supported_rates_len)
 752                         memcpy(__get_dynamic_array(supported_rates),
 753                                params->supported_rates,
 754                                params->supported_rates_len);
 755                 if (params->ext_capab && params->ext_capab_len)
 756                         memcpy(__get_dynamic_array(ext_capab),
 757                                params->ext_capab,
 758                                params->ext_capab_len);
 759                 if (params->supported_channels &&
 760                     params->supported_channels_len)
 761                         memcpy(__get_dynamic_array(supported_channels),
 762                                params->supported_channels,
 763                                params->supported_channels_len);
 764                 if (params->supported_oper_classes &&
 765                     params->supported_oper_classes_len)
 766                         memcpy(__get_dynamic_array(supported_oper_classes),
 767                                params->supported_oper_classes,
 768                                params->supported_oper_classes_len);
 769                 __entry->max_sp = params->max_sp;
 770                 __entry->capability = params->capability;
 771                 __entry->opmode_notif = params->opmode_notif;
 772                 __entry->opmode_notif_used = params->opmode_notif_used;
 773         ),
 774         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT
 775                   ", station flags mask: %u, station flags set: %u, "
 776                   "station modify mask: %u, listen interval: %d, aid: %u, "
 777                   "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s",
 778                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
 779                   __entry->sta_flags_mask, __entry->sta_flags_set,
 780                   __entry->sta_modify_mask, __entry->listen_interval,
 781                   __entry->aid, __entry->plink_action, __entry->plink_state,
 782                   __entry->uapsd_queues, __entry->vlan)
 783 );
 784
 785 DEFINE_EVENT(station_add_change, rdev_add_station,
 786         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
 787                  struct station_parameters *params),
 788         TP_ARGS(wiphy, netdev, mac, params)
 789 );
 790
 791 DEFINE_EVENT(station_add_change, rdev_change_station,
 792         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
 793                  struct station_parameters *params),
 794         TP_ARGS(wiphy, netdev, mac, params)
 795 );
 796
 797 DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt,
 798         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 799         TP_ARGS(wiphy, netdev, mac),
 800         TP_STRUCT__entry(
 801                 WIPHY_ENTRY
 802                 NETDEV_ENTRY
 803                 MAC_ENTRY(sta_mac)
 804         ),
 805         TP_fast_assign(
 806                 WIPHY_ASSIGN;
 807                 NETDEV_ASSIGN;
 808                 MAC_ASSIGN(sta_mac, mac);
 809         ),
 810         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
 811                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac))
 812 );
 813
 814 DECLARE_EVENT_CLASS(station_del,
 815         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 816                  struct station_del_parameters *params),
 817         TP_ARGS(wiphy, netdev, params),
 818         TP_STRUCT__entry(
 819                 WIPHY_ENTRY
 820                 NETDEV_ENTRY
 821                 MAC_ENTRY(sta_mac)
 822                 __field(u8, subtype)
 823                 __field(u16, reason_code)
 824         ),
 825         TP_fast_assign(
 826                 WIPHY_ASSIGN;
 827                 NETDEV_ASSIGN;
 828                 MAC_ASSIGN(sta_mac, params->mac);
 829                 __entry->subtype = params->subtype;
 830                 __entry->reason_code = params->reason_code;
 831         ),
 832         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT
 833                   ", subtype: %u, reason_code: %u",
 834                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
 835                   __entry->subtype, __entry->reason_code)
 836 );
 837
 838 DEFINE_EVENT(station_del, rdev_del_station,
 839         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 840                  struct station_del_parameters *params),
 841         TP_ARGS(wiphy, netdev, params)
 842 );
 843
 844 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station,
 845         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 846         TP_ARGS(wiphy, netdev, mac)
 847 );
 848
 849 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath,
 850         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 851         TP_ARGS(wiphy, netdev, mac)
 852 );
 853
 854 TRACE_EVENT(rdev_dump_station,
 855         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
 856                  u8 *mac),
 857         TP_ARGS(wiphy, netdev, _idx, mac),
 858         TP_STRUCT__entry(
 859                 WIPHY_ENTRY
 860                 NETDEV_ENTRY
 861                 MAC_ENTRY(sta_mac)
 862                 __field(int, idx)
 863         ),
 864         TP_fast_assign(
 865                 WIPHY_ASSIGN;
 866                 NETDEV_ASSIGN;
 867                 MAC_ASSIGN(sta_mac, mac);
 868                 __entry->idx = _idx;
 869         ),
 870         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT ", idx: %d",
 871                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
 872                   __entry->idx)
 873 );
 874
 875 TRACE_EVENT(rdev_return_int_station_info,
 876         TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo),
 877         TP_ARGS(wiphy, ret, sinfo),
 878         TP_STRUCT__entry(
 879                 WIPHY_ENTRY
 880                 __field(int, ret)
 881                 SINFO_ENTRY
 882         ),
 883         TP_fast_assign(
 884                 WIPHY_ASSIGN;
 885                 __entry->ret = ret;
 886                 SINFO_ASSIGN;
 887         ),
 888         TP_printk(WIPHY_PR_FMT ", returned %d" ,
 889                   WIPHY_PR_ARG, __entry->ret)
 890 );
 891
 892 DECLARE_EVENT_CLASS(mpath_evt,
 893         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 894                  u8 *next_hop),
 895         TP_ARGS(wiphy, netdev, dst, next_hop),
 896         TP_STRUCT__entry(
 897                 WIPHY_ENTRY
 898                 NETDEV_ENTRY
 899                 MAC_ENTRY(dst)
 900                 MAC_ENTRY(next_hop)
 901         ),
 902         TP_fast_assign(
 903                 WIPHY_ASSIGN;
 904                 NETDEV_ASSIGN;
 905                 MAC_ASSIGN(dst, dst);
 906                 MAC_ASSIGN(next_hop, next_hop);
 907         ),
 908         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: " MAC_PR_FMT ", next hop: " MAC_PR_FMT,
 909                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dst),
 910                   MAC_PR_ARG(next_hop))
 911 );
 912
 913 DEFINE_EVENT(mpath_evt, rdev_add_mpath,
 914         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 915                  u8 *next_hop),
 916         TP_ARGS(wiphy, netdev, dst, next_hop)
 917 );
 918
 919 DEFINE_EVENT(mpath_evt, rdev_change_mpath,
 920         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 921                  u8 *next_hop),
 922         TP_ARGS(wiphy, netdev, dst, next_hop)
 923 );
 924
 925 DEFINE_EVENT(mpath_evt, rdev_get_mpath,
 926         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 927                  u8 *next_hop),
 928         TP_ARGS(wiphy, netdev, dst, next_hop)
 929 );
 930
 931 TRACE_EVENT(rdev_dump_mpath,
 932         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
 933                  u8 *dst, u8 *next_hop),
 934         TP_ARGS(wiphy, netdev, _idx, dst, next_hop),
 935         TP_STRUCT__entry(
 936                 WIPHY_ENTRY
 937                 NETDEV_ENTRY
 938                 MAC_ENTRY(dst)
 939                 MAC_ENTRY(next_hop)
 940                 __field(int, idx)
 941         ),
 942         TP_fast_assign(
 943                 WIPHY_ASSIGN;
 944                 NETDEV_ASSIGN;
 945                 MAC_ASSIGN(dst, dst);
 946                 MAC_ASSIGN(next_hop, next_hop);
 947                 __entry->idx = _idx;
 948         ),
 949         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: "
 950                   MAC_PR_FMT ", next hop: " MAC_PR_FMT,
 951                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, MAC_PR_ARG(dst),
 952                   MAC_PR_ARG(next_hop))
 953 );
 954
 955 TRACE_EVENT(rdev_get_mpp,
 956         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 957                  u8 *dst, u8 *mpp),
 958         TP_ARGS(wiphy, netdev, dst, mpp),
 959         TP_STRUCT__entry(
 960                 WIPHY_ENTRY
 961                 NETDEV_ENTRY
 962                 MAC_ENTRY(dst)
 963                 MAC_ENTRY(mpp)
 964         ),
 965         TP_fast_assign(
 966                 WIPHY_ASSIGN;
 967                 NETDEV_ASSIGN;
 968                 MAC_ASSIGN(dst, dst);
 969                 MAC_ASSIGN(mpp, mpp);
 970         ),
 971         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: " MAC_PR_FMT
 972                   ", mpp: " MAC_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG,
 973                   MAC_PR_ARG(dst), MAC_PR_ARG(mpp))
 974 );
 975
 976 TRACE_EVENT(rdev_dump_mpp,
 977         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
 978                  u8 *dst, u8 *mpp),
 979         TP_ARGS(wiphy, netdev, _idx, mpp, dst),
 980         TP_STRUCT__entry(
 981                 WIPHY_ENTRY
 982                 NETDEV_ENTRY
 983                 MAC_ENTRY(dst)
 984                 MAC_ENTRY(mpp)
 985                 __field(int, idx)
 986         ),
 987         TP_fast_assign(
 988                 WIPHY_ASSIGN;
 989                 NETDEV_ASSIGN;
 990                 MAC_ASSIGN(dst, dst);
 991                 MAC_ASSIGN(mpp, mpp);
 992                 __entry->idx = _idx;
 993         ),
 994         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: "
 995                   MAC_PR_FMT ", mpp: " MAC_PR_FMT,
 996                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, MAC_PR_ARG(dst),
 997                   MAC_PR_ARG(mpp))
 998 );
 999
1000 TRACE_EVENT(rdev_return_int_mpath_info,
1001         TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo),
1002         TP_ARGS(wiphy, ret, pinfo),
1003         TP_STRUCT__entry(
1004                 WIPHY_ENTRY
1005                 __field(int, ret)
1006                 __field(int, generation)
1007                 __field(u32, filled)
1008                 __field(u32, frame_qlen)
1009                 __field(u32, sn)
1010                 __field(u32, metric)
1011                 __field(u32, exptime)
1012                 __field(u32, discovery_timeout)
1013                 __field(u8, discovery_retries)
1014                 __field(u8, flags)
1015         ),
1016         TP_fast_assign(
1017                 WIPHY_ASSIGN;
1018                 __entry->ret = ret;
1019                 __entry->generation = pinfo->generation;
1020                 __entry->filled = pinfo->filled;
1021                 __entry->frame_qlen = pinfo->frame_qlen;
1022                 __entry->sn = pinfo->sn;
1023                 __entry->metric = pinfo->metric;
1024                 __entry->exptime = pinfo->exptime;
1025                 __entry->discovery_timeout = pinfo->discovery_timeout;
1026                 __entry->discovery_retries = pinfo->discovery_retries;
1027                 __entry->flags = pinfo->flags;
1028         ),
1029         TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, "
1030                   "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u,"
1031                   " discovery timeout: %u, discovery retries: %u, flags: %u",
1032                   WIPHY_PR_ARG, __entry->ret, __entry->generation,
1033                   __entry->filled, __entry->frame_qlen, __entry->sn,
1034                   __entry->metric, __entry->exptime, __entry->discovery_timeout,
1035                   __entry->discovery_retries, __entry->flags)
1036 );
1037
1038 TRACE_EVENT(rdev_return_int_mesh_config,
1039         TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf),
1040         TP_ARGS(wiphy, ret, conf),
1041         TP_STRUCT__entry(
1042                 WIPHY_ENTRY
1043                 MESH_CFG_ENTRY
1044                 __field(int, ret)
1045         ),
1046         TP_fast_assign(
1047                 WIPHY_ASSIGN;
1048                 MESH_CFG_ASSIGN;
1049                 __entry->ret = ret;
1050         ),
1051         TP_printk(WIPHY_PR_FMT ", returned: %d",
1052                   WIPHY_PR_ARG, __entry->ret)
1053 );
1054
1055 TRACE_EVENT(rdev_update_mesh_config,
1056         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask,
1057                  const struct mesh_config *conf),
1058         TP_ARGS(wiphy, netdev, mask, conf),
1059         TP_STRUCT__entry(
1060                 WIPHY_ENTRY
1061                 NETDEV_ENTRY
1062                 MESH_CFG_ENTRY
1063                 __field(u32, mask)
1064         ),
1065         TP_fast_assign(
1066                 WIPHY_ASSIGN;
1067                 NETDEV_ASSIGN;
1068                 MESH_CFG_ASSIGN;
1069                 __entry->mask = mask;
1070         ),
1071         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u",
1072                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask)
1073 );
1074
1075 TRACE_EVENT(rdev_join_mesh,
1076         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1077                  const struct mesh_config *conf,
1078                  const struct mesh_setup *setup),
1079         TP_ARGS(wiphy, netdev, conf, setup),
1080         TP_STRUCT__entry(
1081                 WIPHY_ENTRY
1082                 NETDEV_ENTRY
1083                 MESH_CFG_ENTRY
1084         ),
1085         TP_fast_assign(
1086                 WIPHY_ASSIGN;
1087                 NETDEV_ASSIGN;
1088                 MESH_CFG_ASSIGN;
1089         ),
1090         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
1091                   WIPHY_PR_ARG, NETDEV_PR_ARG)
1092 );
1093
1094 TRACE_EVENT(rdev_change_bss,
1095         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1096                  struct bss_parameters *params),
1097         TP_ARGS(wiphy, netdev, params),
1098         TP_STRUCT__entry(
1099                 WIPHY_ENTRY
1100                 NETDEV_ENTRY
1101                 __field(int, use_cts_prot)
1102                 __field(int, use_short_preamble)
1103                 __field(int, use_short_slot_time)
1104                 __field(int, ap_isolate)
1105                 __field(int, ht_opmode)
1106         ),
1107         TP_fast_assign(
1108                 WIPHY_ASSIGN;
1109                 NETDEV_ASSIGN;
1110                 __entry->use_cts_prot = params->use_cts_prot;
1111                 __entry->use_short_preamble = params->use_short_preamble;
1112                 __entry->use_short_slot_time = params->use_short_slot_time;
1113                 __entry->ap_isolate = params->ap_isolate;
1114                 __entry->ht_opmode = params->ht_opmode;
1115         ),
1116         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, "
1117                   "use short preamble: %d, use short slot time: %d, "
1118                   "ap isolate: %d, ht opmode: %d",
1119                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot,
1120                   __entry->use_short_preamble, __entry->use_short_slot_time,
1121                   __entry->ap_isolate, __entry->ht_opmode)
1122 );
1123
1124 TRACE_EVENT(rdev_set_txq_params,
1125         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1126                  struct ieee80211_txq_params *params),
1127         TP_ARGS(wiphy, netdev, params),
1128         TP_STRUCT__entry(
1129                 WIPHY_ENTRY
1130                 NETDEV_ENTRY
1131                 __field(enum nl80211_ac, ac)
1132                 __field(u16, txop)
1133                 __field(u16, cwmin)
1134                 __field(u16, cwmax)
1135                 __field(u8, aifs)
1136         ),
1137         TP_fast_assign(
1138                 WIPHY_ASSIGN;
1139                 NETDEV_ASSIGN;
1140                 __entry->ac = params->ac;
1141                 __entry->txop = params->txop;
1142                 __entry->cwmin = params->cwmin;
1143                 __entry->cwmax = params->cwmax;
1144                 __entry->aifs = params->aifs;
1145         ),
1146         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u",
1147                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop,
1148                   __entry->cwmin, __entry->cwmax, __entry->aifs)
1149 );
1150
1151 TRACE_EVENT(rdev_libertas_set_mesh_channel,
1152         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1153                  struct ieee80211_channel *chan),
1154         TP_ARGS(wiphy, netdev, chan),
1155         TP_STRUCT__entry(
1156                 WIPHY_ENTRY
1157                 NETDEV_ENTRY
1158                 CHAN_ENTRY
1159         ),
1160         TP_fast_assign(
1161                 WIPHY_ASSIGN;
1162                 NETDEV_ASSIGN;
1163                 CHAN_ASSIGN(chan);
1164         ),
1165         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG,
1166                   NETDEV_PR_ARG, CHAN_PR_ARG)
1167 );
1168
1169 TRACE_EVENT(rdev_set_monitor_channel,
1170         TP_PROTO(struct wiphy *wiphy,
1171                  struct cfg80211_chan_def *chandef),
1172         TP_ARGS(wiphy, chandef),
1173         TP_STRUCT__entry(
1174                 WIPHY_ENTRY
1175                 CHAN_DEF_ENTRY
1176         ),
1177         TP_fast_assign(
1178                 WIPHY_ASSIGN;
1179                 CHAN_DEF_ASSIGN(chandef);
1180         ),
1181         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
1182                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
1183 );
1184
1185 TRACE_EVENT(rdev_auth,
1186         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1187                  struct cfg80211_auth_request *req),
1188         TP_ARGS(wiphy, netdev, req),
1189         TP_STRUCT__entry(
1190                 WIPHY_ENTRY
1191                 NETDEV_ENTRY
1192                 MAC_ENTRY(bssid)
1193                 __field(enum nl80211_auth_type, auth_type)
1194         ),
1195         TP_fast_assign(
1196                 WIPHY_ASSIGN;
1197                 NETDEV_ASSIGN;
1198                 if (req->bss)
1199                         MAC_ASSIGN(bssid, req->bss->bssid);
1200                 else
1201                         eth_zero_addr(__entry->bssid);
1202                 __entry->auth_type = req->auth_type;
1203         ),
1204         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: " MAC_PR_FMT,
1205                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type,
1206                   MAC_PR_ARG(bssid))
1207 );
1208
1209 TRACE_EVENT(rdev_assoc,
1210         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1211                  struct cfg80211_assoc_request *req,
1212                  const struct cfg80211_bss_ies *bss_ies),
1213         TP_ARGS(wiphy, netdev, req, bss_ies),
1214         TP_STRUCT__entry(
1215                 WIPHY_ENTRY
1216                 NETDEV_ENTRY
1217                 MAC_ENTRY(bssid)
1218                 MAC_ENTRY(prev_bssid)
1219                 __field(bool, use_mfp)
1220                 __field(u32, flags)
1221                 __dynamic_array(u8, bss_elements, bss_ies->len)
1222                 __field(bool, bss_elements_bcon)
1223                 __field(u64, bss_elements_tsf)
1224                 __dynamic_array(u8, elements, req->ie_len)
1225                 __array(u8, ht_capa, sizeof(struct ieee80211_ht_cap))
1226                 __array(u8, ht_capa_mask, sizeof(struct ieee80211_ht_cap))
1227                 __array(u8, vht_capa, sizeof(struct ieee80211_vht_cap))
1228                 __array(u8, vht_capa_mask, sizeof(struct ieee80211_vht_cap))
1229                 __dynamic_array(u8, fils_kek, req->fils_kek_len)
1230                 __dynamic_array(u8, fils_nonces,
1231                                 req->fils_nonces ? 2 * FILS_NONCE_LEN : 0)
1232         ),
1233         TP_fast_assign(
1234                 WIPHY_ASSIGN;
1235                 NETDEV_ASSIGN;
1236                 if (req->bss)
1237                         MAC_ASSIGN(bssid, req->bss->bssid);
1238                 else
1239                         eth_zero_addr(__entry->bssid);
1240                 MAC_ASSIGN(prev_bssid, req->prev_bssid);
1241                 __entry->use_mfp = req->use_mfp;
1242                 __entry->flags = req->flags;
1243                 if (bss_ies->len)
1244                         memcpy(__get_dynamic_array(bss_elements),
1245                                bss_ies->data, bss_ies->len);
1246                 __entry->bss_elements_bcon = bss_ies->from_beacon;
1247                 __entry->bss_elements_tsf = bss_ies->tsf;
1248                 if (req->ie)
1249                         memcpy(__get_dynamic_array(elements),
1250                                req->ie, req->ie_len);
1251                 memcpy(__entry->ht_capa, &req->ht_capa, sizeof(req->ht_capa));
1252                 memcpy(__entry->ht_capa_mask, &req->ht_capa_mask,
1253                        sizeof(req->ht_capa_mask));
1254                 memcpy(__entry->vht_capa, &req->vht_capa, sizeof(req->vht_capa));
1255                 memcpy(__entry->vht_capa_mask, &req->vht_capa_mask,
1256                        sizeof(req->vht_capa_mask));
1257                 if (req->fils_kek)
1258                         memcpy(__get_dynamic_array(fils_kek),
1259                                req->fils_kek, req->fils_kek_len);
1260                 if (req->fils_nonces)
1261                         memcpy(__get_dynamic_array(fils_nonces),
1262                                req->fils_nonces, 2 * FILS_NONCE_LEN);
1263         ),
1264         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1265                   ", previous bssid: " MAC_PR_FMT ", use mfp: %s, flags: %u",
1266                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1267                   MAC_PR_ARG(prev_bssid), BOOL_TO_STR(__entry->use_mfp),
1268                   __entry->flags)
1269 );
1270
1271 TRACE_EVENT(rdev_deauth,
1272         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1273                  struct cfg80211_deauth_request *req),
1274         TP_ARGS(wiphy, netdev, req),
1275         TP_STRUCT__entry(
1276                 WIPHY_ENTRY
1277                 NETDEV_ENTRY
1278                 MAC_ENTRY(bssid)
1279                 __field(u16, reason_code)
1280         ),
1281         TP_fast_assign(
1282                 WIPHY_ASSIGN;
1283                 NETDEV_ASSIGN;
1284                 MAC_ASSIGN(bssid, req->bssid);
1285                 __entry->reason_code = req->reason_code;
1286         ),
1287         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", reason: %u",
1288                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1289                   __entry->reason_code)
1290 );
1291
1292 TRACE_EVENT(rdev_disassoc,
1293         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1294                  struct cfg80211_disassoc_request *req),
1295         TP_ARGS(wiphy, netdev, req),
1296         TP_STRUCT__entry(
1297                 WIPHY_ENTRY
1298                 NETDEV_ENTRY
1299                 MAC_ENTRY(bssid)
1300                 __field(u16, reason_code)
1301                 __field(bool, local_state_change)
1302         ),
1303         TP_fast_assign(
1304                 WIPHY_ASSIGN;
1305                 NETDEV_ASSIGN;
1306                 if (req->bss)
1307                         MAC_ASSIGN(bssid, req->bss->bssid);
1308                 else
1309                         eth_zero_addr(__entry->bssid);
1310                 __entry->reason_code = req->reason_code;
1311                 __entry->local_state_change = req->local_state_change;
1312         ),
1313         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1314                   ", reason: %u, local state change: %s",
1315                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1316                   __entry->reason_code,
1317                   BOOL_TO_STR(__entry->local_state_change))
1318 );
1319
1320 TRACE_EVENT(rdev_mgmt_tx_cancel_wait,
1321         TP_PROTO(struct wiphy *wiphy,
1322                  struct wireless_dev *wdev, u64 cookie),
1323         TP_ARGS(wiphy, wdev, cookie),
1324         TP_STRUCT__entry(
1325                 WIPHY_ENTRY
1326                 WDEV_ENTRY
1327                 __field(u64, cookie)
1328         ),
1329         TP_fast_assign(
1330                 WIPHY_ASSIGN;
1331                 WDEV_ASSIGN;
1332                 __entry->cookie = cookie;
1333         ),
1334         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ",
1335                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
1336 );
1337
1338 TRACE_EVENT(rdev_set_power_mgmt,
1339         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1340                  bool enabled, int timeout),
1341         TP_ARGS(wiphy, netdev, enabled, timeout),
1342         TP_STRUCT__entry(
1343                 WIPHY_ENTRY
1344                 NETDEV_ENTRY
1345                 __field(bool, enabled)
1346                 __field(int, timeout)
1347         ),
1348         TP_fast_assign(
1349                 WIPHY_ASSIGN;
1350                 NETDEV_ASSIGN;
1351                 __entry->enabled = enabled;
1352                 __entry->timeout = timeout;
1353         ),
1354         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ",
1355                   WIPHY_PR_ARG, NETDEV_PR_ARG,
1356                   __entry->enabled ? "" : "not ", __entry->timeout)
1357 );
1358
1359 TRACE_EVENT(rdev_connect,
1360         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1361                  struct cfg80211_connect_params *sme),
1362         TP_ARGS(wiphy, netdev, sme),
1363         TP_STRUCT__entry(
1364                 WIPHY_ENTRY
1365                 NETDEV_ENTRY
1366                 MAC_ENTRY(bssid)
1367                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1368                 __field(enum nl80211_auth_type, auth_type)
1369                 __field(bool, privacy)
1370                 __field(u32, wpa_versions)
1371                 __field(u32, flags)
1372                 MAC_ENTRY(prev_bssid)
1373         ),
1374         TP_fast_assign(
1375                 WIPHY_ASSIGN;
1376                 NETDEV_ASSIGN;
1377                 MAC_ASSIGN(bssid, sme->bssid);
1378                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1379                 memcpy(__entry->ssid, sme->ssid, sme->ssid_len);
1380                 __entry->auth_type = sme->auth_type;
1381                 __entry->privacy = sme->privacy;
1382                 __entry->wpa_versions = sme->crypto.wpa_versions;
1383                 __entry->flags = sme->flags;
1384                 MAC_ASSIGN(prev_bssid, sme->prev_bssid);
1385         ),
1386         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1387                   ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, "
1388                   "flags: %u, previous bssid: " MAC_PR_FMT,
1389                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid,
1390                   __entry->auth_type, BOOL_TO_STR(__entry->privacy),
1391                   __entry->wpa_versions, __entry->flags, MAC_PR_ARG(prev_bssid))
1392 );
1393
1394 TRACE_EVENT(rdev_update_connect_params,
1395         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1396                  struct cfg80211_connect_params *sme, u32 changed),
1397         TP_ARGS(wiphy, netdev, sme, changed),
1398         TP_STRUCT__entry(
1399                 WIPHY_ENTRY
1400                 NETDEV_ENTRY
1401                 __field(u32, changed)
1402         ),
1403         TP_fast_assign(
1404                 WIPHY_ASSIGN;
1405                 NETDEV_ASSIGN;
1406                 __entry->changed = changed;
1407         ),
1408         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", parameters changed: %u",
1409                   WIPHY_PR_ARG, NETDEV_PR_ARG,  __entry->changed)
1410 );
1411
1412 TRACE_EVENT(rdev_set_cqm_rssi_config,
1413         TP_PROTO(struct wiphy *wiphy,
1414                  struct net_device *netdev, s32 rssi_thold,
1415                  u32 rssi_hyst),
1416         TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst),
1417         TP_STRUCT__entry(
1418                 WIPHY_ENTRY
1419                 NETDEV_ENTRY
1420                 __field(s32, rssi_thold)
1421                 __field(u32, rssi_hyst)
1422         ),
1423         TP_fast_assign(
1424                 WIPHY_ASSIGN;
1425                 NETDEV_ASSIGN;
1426                 __entry->rssi_thold = rssi_thold;
1427                 __entry->rssi_hyst = rssi_hyst;
1428         ),
1429         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
1430                   ", rssi_thold: %d, rssi_hyst: %u ",
1431                   WIPHY_PR_ARG, NETDEV_PR_ARG,
1432                  __entry->rssi_thold, __entry->rssi_hyst)
1433 );
1434
1435 TRACE_EVENT(rdev_set_cqm_rssi_range_config,
1436         TP_PROTO(struct wiphy *wiphy,
1437                  struct net_device *netdev, s32 low, s32 high),
1438         TP_ARGS(wiphy, netdev, low, high),
1439         TP_STRUCT__entry(
1440                 WIPHY_ENTRY
1441                 NETDEV_ENTRY
1442                 __field(s32, rssi_low)
1443                 __field(s32, rssi_high)
1444         ),
1445         TP_fast_assign(
1446                 WIPHY_ASSIGN;
1447                 NETDEV_ASSIGN;
1448                 __entry->rssi_low = low;
1449                 __entry->rssi_high = high;
1450         ),
1451         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
1452                   ", range: %d - %d ",
1453                   WIPHY_PR_ARG, NETDEV_PR_ARG,
1454                   __entry->rssi_low, __entry->rssi_high)
1455 );
1456
1457 TRACE_EVENT(rdev_set_cqm_txe_config,
1458         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate,
1459                  u32 pkts, u32 intvl),
1460         TP_ARGS(wiphy, netdev, rate, pkts, intvl),
1461         TP_STRUCT__entry(
1462                 WIPHY_ENTRY
1463                 NETDEV_ENTRY
1464                 __field(u32, rate)
1465                 __field(u32, pkts)
1466                 __field(u32, intvl)
1467         ),
1468         TP_fast_assign(
1469                 WIPHY_ASSIGN;
1470                 NETDEV_ASSIGN;
1471                 __entry->rate = rate;
1472                 __entry->pkts = pkts;
1473                 __entry->intvl = intvl;
1474         ),
1475         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u",
1476                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts,
1477                   __entry->intvl)
1478 );
1479
1480 TRACE_EVENT(rdev_disconnect,
1481         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1482                  u16 reason_code),
1483         TP_ARGS(wiphy, netdev, reason_code),
1484         TP_STRUCT__entry(
1485                 WIPHY_ENTRY
1486                 NETDEV_ENTRY
1487                 __field(u16, reason_code)
1488         ),
1489         TP_fast_assign(
1490                 WIPHY_ASSIGN;
1491                 NETDEV_ASSIGN;
1492                 __entry->reason_code = reason_code;
1493         ),
1494         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG,
1495                   NETDEV_PR_ARG, __entry->reason_code)
1496 );
1497
1498 TRACE_EVENT(rdev_join_ibss,
1499         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1500                  struct cfg80211_ibss_params *params),
1501         TP_ARGS(wiphy, netdev, params),
1502         TP_STRUCT__entry(
1503                 WIPHY_ENTRY
1504                 NETDEV_ENTRY
1505                 MAC_ENTRY(bssid)
1506                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1507         ),
1508         TP_fast_assign(
1509                 WIPHY_ASSIGN;
1510                 NETDEV_ASSIGN;
1511                 MAC_ASSIGN(bssid, params->bssid);
1512                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1513                 memcpy(__entry->ssid, params->ssid, params->ssid_len);
1514         ),
1515         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", ssid: %s",
1516                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid)
1517 );
1518
1519 TRACE_EVENT(rdev_join_ocb,
1520         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1521                  const struct ocb_setup *setup),
1522         TP_ARGS(wiphy, netdev, setup),
1523         TP_STRUCT__entry(
1524                 WIPHY_ENTRY
1525                 NETDEV_ENTRY
1526         ),
1527         TP_fast_assign(
1528                 WIPHY_ASSIGN;
1529                 NETDEV_ASSIGN;
1530         ),
1531         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
1532                   WIPHY_PR_ARG, NETDEV_PR_ARG)
1533 );
1534
1535 TRACE_EVENT(rdev_set_wiphy_params,
1536         TP_PROTO(struct wiphy *wiphy, u32 changed),
1537         TP_ARGS(wiphy, changed),
1538         TP_STRUCT__entry(
1539                 WIPHY_ENTRY
1540                 __field(u32, changed)
1541         ),
1542         TP_fast_assign(
1543                 WIPHY_ASSIGN;
1544                 __entry->changed = changed;
1545         ),
1546         TP_printk(WIPHY_PR_FMT ", changed: %u",
1547                   WIPHY_PR_ARG, __entry->changed)
1548 );
1549
1550 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power,
1551         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1552         TP_ARGS(wiphy, wdev)
1553 );
1554
1555 TRACE_EVENT(rdev_set_tx_power,
1556         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1557                  enum nl80211_tx_power_setting type, int mbm),
1558         TP_ARGS(wiphy, wdev, type, mbm),
1559         TP_STRUCT__entry(
1560                 WIPHY_ENTRY
1561                 WDEV_ENTRY
1562                 __field(enum nl80211_tx_power_setting, type)
1563                 __field(int, mbm)
1564         ),
1565         TP_fast_assign(
1566                 WIPHY_ASSIGN;
1567                 WDEV_ASSIGN;
1568                 __entry->type = type;
1569                 __entry->mbm = mbm;
1570         ),
1571         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type: %u, mbm: %d",
1572                   WIPHY_PR_ARG, WDEV_PR_ARG,__entry->type, __entry->mbm)
1573 );
1574
1575 TRACE_EVENT(rdev_return_int_int,
1576         TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill),
1577         TP_ARGS(wiphy, func_ret, func_fill),
1578         TP_STRUCT__entry(
1579                 WIPHY_ENTRY
1580                 __field(int, func_ret)
1581                 __field(int, func_fill)
1582         ),
1583         TP_fast_assign(
1584                 WIPHY_ASSIGN;
1585                 __entry->func_ret = func_ret;
1586                 __entry->func_fill = func_fill;
1587         ),
1588         TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d",
1589                   WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill)
1590 );
1591
1592 #ifdef CONFIG_NL80211_TESTMODE
1593 TRACE_EVENT(rdev_testmode_cmd,
1594         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1595         TP_ARGS(wiphy, wdev),
1596         TP_STRUCT__entry(
1597                 WIPHY_ENTRY
1598                 WDEV_ENTRY
1599         ),
1600         TP_fast_assign(
1601                 WIPHY_ASSIGN;
1602                 WDEV_ASSIGN;
1603         ),
1604         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
1605 );
1606
1607 TRACE_EVENT(rdev_testmode_dump,
1608         TP_PROTO(struct wiphy *wiphy),
1609         TP_ARGS(wiphy),
1610         TP_STRUCT__entry(
1611                 WIPHY_ENTRY
1612         ),
1613         TP_fast_assign(
1614                 WIPHY_ASSIGN;
1615         ),
1616         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
1617 );
1618 #endif /* CONFIG_NL80211_TESTMODE */
1619
1620 TRACE_EVENT(rdev_set_bitrate_mask,
1621         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1622                  const u8 *peer, const struct cfg80211_bitrate_mask *mask),
1623         TP_ARGS(wiphy, netdev, peer, mask),
1624         TP_STRUCT__entry(
1625                 WIPHY_ENTRY
1626                 NETDEV_ENTRY
1627                 MAC_ENTRY(peer)
1628         ),
1629         TP_fast_assign(
1630                 WIPHY_ASSIGN;
1631                 NETDEV_ASSIGN;
1632                 MAC_ASSIGN(peer, peer);
1633         ),
1634         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT,
1635                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
1636 );
1637
1638 TRACE_EVENT(rdev_update_mgmt_frame_registrations,
1639         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1640                  struct mgmt_frame_regs *upd),
1641         TP_ARGS(wiphy, wdev, upd),
1642         TP_STRUCT__entry(
1643                 WIPHY_ENTRY
1644                 WDEV_ENTRY
1645                 __field(u16, global_stypes)
1646                 __field(u16, interface_stypes)
1647         ),
1648         TP_fast_assign(
1649                 WIPHY_ASSIGN;
1650                 WDEV_ASSIGN;
1651                 __entry->global_stypes = upd->global_stypes;
1652                 __entry->interface_stypes = upd->interface_stypes;
1653         ),
1654         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", global: 0x%.2x, intf: 0x%.2x",
1655                   WIPHY_PR_ARG, WDEV_PR_ARG,
1656                   __entry->global_stypes, __entry->interface_stypes)
1657 );
1658
1659 TRACE_EVENT(rdev_return_int_tx_rx,
1660         TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx),
1661         TP_ARGS(wiphy, ret, tx, rx),
1662         TP_STRUCT__entry(
1663                 WIPHY_ENTRY
1664                 __field(int, ret)
1665                 __field(u32, tx)
1666                 __field(u32, rx)
1667         ),
1668         TP_fast_assign(
1669                 WIPHY_ASSIGN;
1670                 __entry->ret = ret;
1671                 __entry->tx = tx;
1672                 __entry->rx = rx;
1673         ),
1674         TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u",
1675                   WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx)
1676 );
1677
1678 TRACE_EVENT(rdev_return_void_tx_rx,
1679         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max,
1680                  u32 rx, u32 rx_max),
1681         TP_ARGS(wiphy, tx, tx_max, rx, rx_max),
1682         TP_STRUCT__entry(
1683                 WIPHY_ENTRY
1684                 __field(u32, tx)
1685                 __field(u32, tx_max)
1686                 __field(u32, rx)
1687                 __field(u32, rx_max)
1688         ),
1689         TP_fast_assign(
1690                 WIPHY_ASSIGN;
1691                 __entry->tx = tx;
1692                 __entry->tx_max = tx_max;
1693                 __entry->rx = rx;
1694                 __entry->rx_max = rx_max;
1695         ),
1696         TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ",
1697                   WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx,
1698                   __entry->rx_max)
1699 );
1700
1701 DECLARE_EVENT_CLASS(tx_rx_evt,
1702         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
1703         TP_ARGS(wiphy, rx, tx),
1704         TP_STRUCT__entry(
1705                 WIPHY_ENTRY
1706                 __field(u32, tx)
1707                 __field(u32, rx)
1708         ),
1709         TP_fast_assign(
1710                 WIPHY_ASSIGN;
1711                 __entry->tx = tx;
1712                 __entry->rx = rx;
1713         ),
1714         TP_printk(WIPHY_PR_FMT ", tx: %u, rx: %u ",
1715                   WIPHY_PR_ARG, __entry->tx, __entry->rx)
1716 );
1717
1718 DEFINE_EVENT(tx_rx_evt, rdev_set_antenna,
1719         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
1720         TP_ARGS(wiphy, rx, tx)
1721 );
1722
1723 DECLARE_EVENT_CLASS(wiphy_netdev_id_evt,
1724         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
1725         TP_ARGS(wiphy, netdev, id),
1726         TP_STRUCT__entry(
1727                 WIPHY_ENTRY
1728                 NETDEV_ENTRY
1729                 __field(u64, id)
1730         ),
1731         TP_fast_assign(
1732                 WIPHY_ASSIGN;
1733                 NETDEV_ASSIGN;
1734                 __entry->id = id;
1735         ),
1736         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", id: %llu",
1737                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->id)
1738 );
1739
1740 DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start,
1741         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
1742         TP_ARGS(wiphy, netdev, id)
1743 );
1744
1745 DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop,
1746         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
1747         TP_ARGS(wiphy, netdev, id)
1748 );
1749
1750 TRACE_EVENT(rdev_tdls_mgmt,
1751         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1752                  u8 *peer, u8 action_code, u8 dialog_token,
1753                  u16 status_code, u32 peer_capability,
1754                  bool initiator, const u8 *buf, size_t len),
1755         TP_ARGS(wiphy, netdev, peer, action_code, dialog_token, status_code,
1756                 peer_capability, initiator, buf, len),
1757         TP_STRUCT__entry(
1758                 WIPHY_ENTRY
1759                 NETDEV_ENTRY
1760                 MAC_ENTRY(peer)
1761                 __field(u8, action_code)
1762                 __field(u8, dialog_token)
1763                 __field(u16, status_code)
1764                 __field(u32, peer_capability)
1765                 __field(bool, initiator)
1766                 __dynamic_array(u8, buf, len)
1767         ),
1768         TP_fast_assign(
1769                 WIPHY_ASSIGN;
1770                 NETDEV_ASSIGN;
1771                 MAC_ASSIGN(peer, peer);
1772                 __entry->action_code = action_code;
1773                 __entry->dialog_token = dialog_token;
1774                 __entry->status_code = status_code;
1775                 __entry->peer_capability = peer_capability;
1776                 __entry->initiator = initiator;
1777                 memcpy(__get_dynamic_array(buf), buf, len);
1778         ),
1779         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", action_code: %u, "
1780                   "dialog_token: %u, status_code: %u, peer_capability: %u "
1781                   "initiator: %s buf: %#.2x ",
1782                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
1783                   __entry->action_code, __entry->dialog_token,
1784                   __entry->status_code, __entry->peer_capability,
1785                   BOOL_TO_STR(__entry->initiator),
1786                   ((u8 *)__get_dynamic_array(buf))[0])
1787 );
1788
1789 TRACE_EVENT(rdev_dump_survey,
1790         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx),
1791         TP_ARGS(wiphy, netdev, _idx),
1792         TP_STRUCT__entry(
1793                 WIPHY_ENTRY
1794                 NETDEV_ENTRY
1795                 __field(int, idx)
1796         ),
1797         TP_fast_assign(
1798                 WIPHY_ASSIGN;
1799                 NETDEV_ASSIGN;
1800                 __entry->idx = _idx;
1801         ),
1802         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d",
1803                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx)
1804 );
1805
1806 TRACE_EVENT(rdev_return_int_survey_info,
1807         TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info),
1808         TP_ARGS(wiphy, ret, info),
1809         TP_STRUCT__entry(
1810                 WIPHY_ENTRY
1811                 CHAN_ENTRY
1812                 __field(int, ret)
1813                 __field(u64, time)
1814                 __field(u64, time_busy)
1815                 __field(u64, time_ext_busy)
1816                 __field(u64, time_rx)
1817                 __field(u64, time_tx)
1818                 __field(u64, time_scan)
1819                 __field(u32, filled)
1820                 __field(s8, noise)
1821         ),
1822         TP_fast_assign(
1823                 WIPHY_ASSIGN;
1824                 CHAN_ASSIGN(info->channel);
1825                 __entry->ret = ret;
1826                 __entry->time = info->time;
1827                 __entry->time_busy = info->time_busy;
1828                 __entry->time_ext_busy = info->time_ext_busy;
1829                 __entry->time_rx = info->time_rx;
1830                 __entry->time_tx = info->time_tx;
1831                 __entry->time_scan = info->time_scan;
1832                 __entry->filled = info->filled;
1833                 __entry->noise = info->noise;
1834         ),
1835         TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT
1836                   ", channel time: %llu, channel time busy: %llu, "
1837                   "channel time extension busy: %llu, channel time rx: %llu, "
1838                   "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d",
1839                   WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG,
1840                   __entry->time, __entry->time_busy,
1841                   __entry->time_ext_busy, __entry->time_rx,
1842                   __entry->time_tx, __entry->time_scan,
1843                   __entry->filled, __entry->noise)
1844 );
1845
1846 TRACE_EVENT(rdev_tdls_oper,
1847         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1848                  u8 *peer, enum nl80211_tdls_operation oper),
1849         TP_ARGS(wiphy, netdev, peer, oper),
1850         TP_STRUCT__entry(
1851                 WIPHY_ENTRY
1852                 NETDEV_ENTRY
1853                 MAC_ENTRY(peer)
1854                 __field(enum nl80211_tdls_operation, oper)
1855         ),
1856         TP_fast_assign(
1857                 WIPHY_ASSIGN;
1858                 NETDEV_ASSIGN;
1859                 MAC_ASSIGN(peer, peer);
1860                 __entry->oper = oper;
1861         ),
1862         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", oper: %d",
1863                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper)
1864 );
1865
1866 DECLARE_EVENT_CLASS(rdev_pmksa,
1867         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1868                  struct cfg80211_pmksa *pmksa),
1869         TP_ARGS(wiphy, netdev, pmksa),
1870         TP_STRUCT__entry(
1871                 WIPHY_ENTRY
1872                 NETDEV_ENTRY
1873                 MAC_ENTRY(bssid)
1874         ),
1875         TP_fast_assign(
1876                 WIPHY_ASSIGN;
1877                 NETDEV_ASSIGN;
1878                 MAC_ASSIGN(bssid, pmksa->bssid);
1879         ),
1880         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT,
1881                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid))
1882 );
1883
1884 TRACE_EVENT(rdev_probe_client,
1885         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1886                  const u8 *peer),
1887         TP_ARGS(wiphy, netdev, peer),
1888         TP_STRUCT__entry(
1889                 WIPHY_ENTRY
1890                 NETDEV_ENTRY
1891                 MAC_ENTRY(peer)
1892         ),
1893         TP_fast_assign(
1894                 WIPHY_ASSIGN;
1895                 NETDEV_ASSIGN;
1896                 MAC_ASSIGN(peer, peer);
1897         ),
1898         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
1899                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
1900 );
1901
1902 DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa,
1903         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1904                  struct cfg80211_pmksa *pmksa),
1905         TP_ARGS(wiphy, netdev, pmksa)
1906 );
1907
1908 DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa,
1909         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1910                  struct cfg80211_pmksa *pmksa),
1911         TP_ARGS(wiphy, netdev, pmksa)
1912 );
1913
1914 TRACE_EVENT(rdev_remain_on_channel,
1915         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1916                  struct ieee80211_channel *chan,
1917                  unsigned int duration),
1918         TP_ARGS(wiphy, wdev, chan, duration),
1919         TP_STRUCT__entry(
1920                 WIPHY_ENTRY
1921                 WDEV_ENTRY
1922                 CHAN_ENTRY
1923                 __field(unsigned int, duration)
1924         ),
1925         TP_fast_assign(
1926                 WIPHY_ASSIGN;
1927                 WDEV_ASSIGN;
1928                 CHAN_ASSIGN(chan);
1929                 __entry->duration = duration;
1930         ),
1931         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u",
1932                   WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration)
1933 );
1934
1935 TRACE_EVENT(rdev_return_int_cookie,
1936         TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie),
1937         TP_ARGS(wiphy, ret, cookie),
1938         TP_STRUCT__entry(
1939                 WIPHY_ENTRY
1940                 __field(int, ret)
1941                 __field(u64, cookie)
1942         ),
1943         TP_fast_assign(
1944                 WIPHY_ASSIGN;
1945                 __entry->ret = ret;
1946                 __entry->cookie = cookie;
1947         ),
1948         TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu",
1949                   WIPHY_PR_ARG, __entry->ret, __entry->cookie)
1950 );
1951
1952 TRACE_EVENT(rdev_cancel_remain_on_channel,
1953         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
1954         TP_ARGS(wiphy, wdev, cookie),
1955         TP_STRUCT__entry(
1956                 WIPHY_ENTRY
1957                 WDEV_ENTRY
1958                 __field(u64, cookie)
1959         ),
1960         TP_fast_assign(
1961                 WIPHY_ASSIGN;
1962                 WDEV_ASSIGN;
1963                 __entry->cookie = cookie;
1964         ),
1965         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu",
1966                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
1967 );
1968
1969 TRACE_EVENT(rdev_mgmt_tx,
1970         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1971                  struct cfg80211_mgmt_tx_params *params),
1972         TP_ARGS(wiphy, wdev, params),
1973         TP_STRUCT__entry(
1974                 WIPHY_ENTRY
1975                 WDEV_ENTRY
1976                 CHAN_ENTRY
1977                 __field(bool, offchan)
1978                 __field(unsigned int, wait)
1979                 __field(bool, no_cck)
1980                 __field(bool, dont_wait_for_ack)
1981         ),
1982         TP_fast_assign(
1983                 WIPHY_ASSIGN;
1984                 WDEV_ASSIGN;
1985                 CHAN_ASSIGN(params->chan);
1986                 __entry->offchan = params->offchan;
1987                 __entry->wait = params->wait;
1988                 __entry->no_cck = params->no_cck;
1989                 __entry->dont_wait_for_ack = params->dont_wait_for_ack;
1990         ),
1991         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s,"
1992                   " wait: %u, no cck: %s, dont wait for ack: %s",
1993                   WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG,
1994                   BOOL_TO_STR(__entry->offchan), __entry->wait,
1995                   BOOL_TO_STR(__entry->no_cck),
1996                   BOOL_TO_STR(__entry->dont_wait_for_ack))
1997 );
1998
1999 TRACE_EVENT(rdev_tx_control_port,
2000         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2001                  const u8 *buf, size_t len, const u8 *dest, __be16 proto,
2002                  bool unencrypted),
2003         TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted),
2004         TP_STRUCT__entry(
2005                 WIPHY_ENTRY
2006                 NETDEV_ENTRY
2007                 MAC_ENTRY(dest)
2008                 __field(__be16, proto)
2009                 __field(bool, unencrypted)
2010         ),
2011         TP_fast_assign(
2012                 WIPHY_ASSIGN;
2013                 NETDEV_ASSIGN;
2014                 MAC_ASSIGN(dest, dest);
2015                 __entry->proto = proto;
2016                 __entry->unencrypted = unencrypted;
2017         ),
2018         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ","
2019                   " proto: 0x%x, unencrypted: %s",
2020                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dest),
2021                   be16_to_cpu(__entry->proto),
2022                   BOOL_TO_STR(__entry->unencrypted))
2023 );
2024
2025 TRACE_EVENT(rdev_set_noack_map,
2026         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2027                  u16 noack_map),
2028         TP_ARGS(wiphy, netdev, noack_map),
2029         TP_STRUCT__entry(
2030                 WIPHY_ENTRY
2031                 NETDEV_ENTRY
2032                 __field(u16, noack_map)
2033         ),
2034         TP_fast_assign(
2035                 WIPHY_ASSIGN;
2036                 NETDEV_ASSIGN;
2037                 __entry->noack_map = noack_map;
2038         ),
2039         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u",
2040                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map)
2041 );
2042
2043 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel,
2044         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2045         TP_ARGS(wiphy, wdev)
2046 );
2047
2048 TRACE_EVENT(rdev_return_chandef,
2049         TP_PROTO(struct wiphy *wiphy, int ret,
2050                  struct cfg80211_chan_def *chandef),
2051         TP_ARGS(wiphy, ret, chandef),
2052         TP_STRUCT__entry(
2053                 WIPHY_ENTRY
2054                 __field(int, ret)
2055                 CHAN_DEF_ENTRY
2056         ),
2057         TP_fast_assign(
2058                 WIPHY_ASSIGN;
2059                 if (ret == 0)
2060                         CHAN_DEF_ASSIGN(chandef);
2061                 else
2062                         CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL);
2063                 __entry->ret = ret;
2064         ),
2065         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d",
2066                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret)
2067 );
2068
2069 DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device,
2070         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2071         TP_ARGS(wiphy, wdev)
2072 );
2073
2074 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device,
2075         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2076         TP_ARGS(wiphy, wdev)
2077 );
2078
2079 TRACE_EVENT(rdev_start_nan,
2080         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2081                  struct cfg80211_nan_conf *conf),
2082         TP_ARGS(wiphy, wdev, conf),
2083         TP_STRUCT__entry(
2084                 WIPHY_ENTRY
2085                 WDEV_ENTRY
2086                 __field(u8, master_pref)
2087                 __field(u8, bands)
2088         ),
2089         TP_fast_assign(
2090                 WIPHY_ASSIGN;
2091                 WDEV_ASSIGN;
2092                 __entry->master_pref = conf->master_pref;
2093                 __entry->bands = conf->bands;
2094         ),
2095         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
2096                   ", master preference: %u, bands: 0x%0x",
2097                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref,
2098                   __entry->bands)
2099 );
2100
2101 TRACE_EVENT(rdev_nan_change_conf,
2102         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2103                  struct cfg80211_nan_conf *conf, u32 changes),
2104         TP_ARGS(wiphy, wdev, conf, changes),
2105         TP_STRUCT__entry(
2106                 WIPHY_ENTRY
2107                 WDEV_ENTRY
2108                 __field(u8, master_pref)
2109                 __field(u8, bands)
2110                 __field(u32, changes)
2111         ),
2112         TP_fast_assign(
2113                 WIPHY_ASSIGN;
2114                 WDEV_ASSIGN;
2115                 __entry->master_pref = conf->master_pref;
2116                 __entry->bands = conf->bands;
2117                 __entry->changes = changes;
2118         ),
2119         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
2120                   ", master preference: %u, bands: 0x%0x, changes: %x",
2121                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref,
2122                   __entry->bands, __entry->changes)
2123 );
2124
2125 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan,
2126         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2127         TP_ARGS(wiphy, wdev)
2128 );
2129
2130 TRACE_EVENT(rdev_add_nan_func,
2131         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2132                  const struct cfg80211_nan_func *func),
2133         TP_ARGS(wiphy, wdev, func),
2134         TP_STRUCT__entry(
2135                 WIPHY_ENTRY
2136                 WDEV_ENTRY
2137                 __field(u8, func_type)
2138                 __field(u64, cookie)
2139         ),
2140         TP_fast_assign(
2141                 WIPHY_ASSIGN;
2142                 WDEV_ASSIGN;
2143                 __entry->func_type = func->type;
2144                 __entry->cookie = func->cookie
2145         ),
2146         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type=%u, cookie=%llu",
2147                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->func_type,
2148                   __entry->cookie)
2149 );
2150
2151 TRACE_EVENT(rdev_del_nan_func,
2152         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2153                  u64 cookie),
2154         TP_ARGS(wiphy, wdev, cookie),
2155         TP_STRUCT__entry(
2156                 WIPHY_ENTRY
2157                 WDEV_ENTRY
2158                 __field(u64, cookie)
2159         ),
2160         TP_fast_assign(
2161                 WIPHY_ASSIGN;
2162                 WDEV_ASSIGN;
2163                 __entry->cookie = cookie;
2164         ),
2165         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie=%llu",
2166                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
2167 );
2168
2169 TRACE_EVENT(rdev_set_mac_acl,
2170         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2171                  struct cfg80211_acl_data *params),
2172         TP_ARGS(wiphy, netdev, params),
2173         TP_STRUCT__entry(
2174                 WIPHY_ENTRY
2175                 NETDEV_ENTRY
2176                 __field(u32, acl_policy)
2177         ),
2178         TP_fast_assign(
2179                 WIPHY_ASSIGN;
2180                 NETDEV_ASSIGN;
2181                 __entry->acl_policy = params->acl_policy;
2182         ),
2183         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d",
2184                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy)
2185 );
2186
2187 TRACE_EVENT(rdev_update_ft_ies,
2188         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2189                  struct cfg80211_update_ft_ies_params *ftie),
2190         TP_ARGS(wiphy, netdev, ftie),
2191         TP_STRUCT__entry(
2192                 WIPHY_ENTRY
2193                 NETDEV_ENTRY
2194                 __field(u16, md)
2195                 __dynamic_array(u8, ie, ftie->ie_len)
2196         ),
2197         TP_fast_assign(
2198                 WIPHY_ASSIGN;
2199                 NETDEV_ASSIGN;
2200                 __entry->md = ftie->md;
2201                 memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len);
2202         ),
2203         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x",
2204                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md)
2205 );
2206
2207 TRACE_EVENT(rdev_crit_proto_start,
2208         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2209                  enum nl80211_crit_proto_id protocol, u16 duration),
2210         TP_ARGS(wiphy, wdev, protocol, duration),
2211         TP_STRUCT__entry(
2212                 WIPHY_ENTRY
2213                 WDEV_ENTRY
2214                 __field(u16, proto)
2215                 __field(u16, duration)
2216         ),
2217         TP_fast_assign(
2218                 WIPHY_ASSIGN;
2219                 WDEV_ASSIGN;
2220                 __entry->proto = protocol;
2221                 __entry->duration = duration;
2222         ),
2223         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u",
2224                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration)
2225 );
2226
2227 TRACE_EVENT(rdev_crit_proto_stop,
2228         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2229         TP_ARGS(wiphy, wdev),
2230         TP_STRUCT__entry(
2231                 WIPHY_ENTRY
2232                 WDEV_ENTRY
2233         ),
2234         TP_fast_assign(
2235                 WIPHY_ASSIGN;
2236                 WDEV_ASSIGN;
2237         ),
2238         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
2239                   WIPHY_PR_ARG, WDEV_PR_ARG)
2240 );
2241
2242 TRACE_EVENT(rdev_channel_switch,
2243         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2244                  struct cfg80211_csa_settings *params),
2245         TP_ARGS(wiphy, netdev, params),
2246         TP_STRUCT__entry(
2247                 WIPHY_ENTRY
2248                 NETDEV_ENTRY
2249                 CHAN_DEF_ENTRY
2250                 __field(bool, radar_required)
2251                 __field(bool, block_tx)
2252                 __field(u8, count)
2253                 __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon)
2254                 __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp)
2255         ),
2256         TP_fast_assign(
2257                 WIPHY_ASSIGN;
2258                 NETDEV_ASSIGN;
2259                 CHAN_DEF_ASSIGN(&params->chandef);
2260                 __entry->radar_required = params->radar_required;
2261                 __entry->block_tx = params->block_tx;
2262                 __entry->count = params->count;
2263                 memcpy(__get_dynamic_array(bcn_ofs),
2264                        params->counter_offsets_beacon,
2265                        params->n_counter_offsets_beacon * sizeof(u16));
2266
2267                 /* probe response offsets are optional */
2268                 if (params->n_counter_offsets_presp)
2269                         memcpy(__get_dynamic_array(pres_ofs),
2270                                params->counter_offsets_presp,
2271                                params->n_counter_offsets_presp * sizeof(u16));
2272         ),
2273         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT
2274                   ", block_tx: %d, count: %u, radar_required: %d",
2275                   WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
2276                   __entry->block_tx, __entry->count, __entry->radar_required)
2277 );
2278
2279 TRACE_EVENT(rdev_set_qos_map,
2280         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2281                  struct cfg80211_qos_map *qos_map),
2282         TP_ARGS(wiphy, netdev, qos_map),
2283         TP_STRUCT__entry(
2284                 WIPHY_ENTRY
2285                 NETDEV_ENTRY
2286                 QOS_MAP_ENTRY
2287         ),
2288         TP_fast_assign(
2289                 WIPHY_ASSIGN;
2290                 NETDEV_ASSIGN;
2291                 QOS_MAP_ASSIGN(qos_map);
2292         ),
2293         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u",
2294                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des)
2295 );
2296
2297 TRACE_EVENT(rdev_set_ap_chanwidth,
2298         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2299                  struct cfg80211_chan_def *chandef),
2300         TP_ARGS(wiphy, netdev, chandef),
2301         TP_STRUCT__entry(
2302                 WIPHY_ENTRY
2303                 NETDEV_ENTRY
2304                 CHAN_DEF_ENTRY
2305         ),
2306         TP_fast_assign(
2307                 WIPHY_ASSIGN;
2308                 NETDEV_ASSIGN;
2309                 CHAN_DEF_ASSIGN(chandef);
2310         ),
2311         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
2312                   WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
2313 );
2314
2315 TRACE_EVENT(rdev_add_tx_ts,
2316         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2317                  u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time),
2318         TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time),
2319         TP_STRUCT__entry(
2320                 WIPHY_ENTRY
2321                 NETDEV_ENTRY
2322                 MAC_ENTRY(peer)
2323                 __field(u8, tsid)
2324                 __field(u8, user_prio)
2325                 __field(u16, admitted_time)
2326         ),
2327         TP_fast_assign(
2328                 WIPHY_ASSIGN;
2329                 NETDEV_ASSIGN;
2330                 MAC_ASSIGN(peer, peer);
2331                 __entry->tsid = tsid;
2332                 __entry->user_prio = user_prio;
2333                 __entry->admitted_time = admitted_time;
2334         ),
2335         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d, UP %d, time %d",
2336                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
2337                   __entry->tsid, __entry->user_prio, __entry->admitted_time)
2338 );
2339
2340 TRACE_EVENT(rdev_del_tx_ts,
2341         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2342                  u8 tsid, const u8 *peer),
2343         TP_ARGS(wiphy, netdev, tsid, peer),
2344         TP_STRUCT__entry(
2345                 WIPHY_ENTRY
2346                 NETDEV_ENTRY
2347                 MAC_ENTRY(peer)
2348                 __field(u8, tsid)
2349         ),
2350         TP_fast_assign(
2351                 WIPHY_ASSIGN;
2352                 NETDEV_ASSIGN;
2353                 MAC_ASSIGN(peer, peer);
2354                 __entry->tsid = tsid;
2355         ),
2356         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d",
2357                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->tsid)
2358 );
2359
2360 TRACE_EVENT(rdev_tdls_channel_switch,
2361         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2362                  const u8 *addr, u8 oper_class,
2363                  struct cfg80211_chan_def *chandef),
2364         TP_ARGS(wiphy, netdev, addr, oper_class, chandef),
2365         TP_STRUCT__entry(
2366                 WIPHY_ENTRY
2367                 NETDEV_ENTRY
2368                 MAC_ENTRY(addr)
2369                 __field(u8, oper_class)
2370                 CHAN_DEF_ENTRY
2371         ),
2372         TP_fast_assign(
2373                 WIPHY_ASSIGN;
2374                 NETDEV_ASSIGN;
2375                 MAC_ASSIGN(addr, addr);
2376                 CHAN_DEF_ASSIGN(chandef);
2377         ),
2378         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT
2379                   " oper class %d, " CHAN_DEF_PR_FMT,
2380                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr),
2381                   __entry->oper_class, CHAN_DEF_PR_ARG)
2382 );
2383
2384 TRACE_EVENT(rdev_tdls_cancel_channel_switch,
2385         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2386                  const u8 *addr),
2387         TP_ARGS(wiphy, netdev, addr),
2388         TP_STRUCT__entry(
2389                 WIPHY_ENTRY
2390                 NETDEV_ENTRY
2391                 MAC_ENTRY(addr)
2392         ),
2393         TP_fast_assign(
2394                 WIPHY_ASSIGN;
2395                 NETDEV_ASSIGN;
2396                 MAC_ASSIGN(addr, addr);
2397         ),
2398         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
2399                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr))
2400 );
2401
2402 TRACE_EVENT(rdev_set_pmk,
2403         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2404                  struct cfg80211_pmk_conf *pmk_conf),
2405
2406         TP_ARGS(wiphy, netdev, pmk_conf),
2407
2408         TP_STRUCT__entry(
2409                 WIPHY_ENTRY
2410                 NETDEV_ENTRY
2411                 MAC_ENTRY(aa)
2412                 __field(u8, pmk_len)
2413                 __field(u8, pmk_r0_name_len)
2414                 __dynamic_array(u8, pmk, pmk_conf->pmk_len)
2415                 __dynamic_array(u8, pmk_r0_name, WLAN_PMK_NAME_LEN)
2416         ),
2417
2418         TP_fast_assign(
2419                 WIPHY_ASSIGN;
2420                 NETDEV_ASSIGN;
2421                 MAC_ASSIGN(aa, pmk_conf->aa);
2422                 __entry->pmk_len = pmk_conf->pmk_len;
2423                 __entry->pmk_r0_name_len =
2424                 pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0;
2425                 memcpy(__get_dynamic_array(pmk), pmk_conf->pmk,
2426                        pmk_conf->pmk_len);
2427                 memcpy(__get_dynamic_array(pmk_r0_name), pmk_conf->pmk_r0_name,
2428                        pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0);
2429         ),
2430
2431         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT
2432                   "pmk_len=%u, pmk: %s pmk_r0_name: %s", WIPHY_PR_ARG,
2433                   NETDEV_PR_ARG, MAC_PR_ARG(aa), __entry->pmk_len,
2434                   __print_array(__get_dynamic_array(pmk),
2435                                 __get_dynamic_array_len(pmk), 1),
2436                   __entry->pmk_r0_name_len ?
2437                   __print_array(__get_dynamic_array(pmk_r0_name),
2438                                 __get_dynamic_array_len(pmk_r0_name), 1) : "")
2439 );
2440
2441 TRACE_EVENT(rdev_del_pmk,
2442         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa),
2443
2444         TP_ARGS(wiphy, netdev, aa),
2445
2446         TP_STRUCT__entry(
2447                 WIPHY_ENTRY
2448                 NETDEV_ENTRY
2449                 MAC_ENTRY(aa)
2450         ),
2451
2452         TP_fast_assign(
2453                 WIPHY_ASSIGN;
2454                 NETDEV_ASSIGN;
2455                 MAC_ASSIGN(aa, aa);
2456         ),
2457
2458         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
2459                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(aa))
2460 );
2461
2462 TRACE_EVENT(rdev_external_auth,
2463             TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2464                      struct cfg80211_external_auth_params *params),
2465             TP_ARGS(wiphy, netdev, params),
2466             TP_STRUCT__entry(WIPHY_ENTRY
2467                              NETDEV_ENTRY
2468                              MAC_ENTRY(bssid)
2469                              __array(u8, ssid, IEEE80211_MAX_SSID_LEN + 1)
2470                              __field(u16, status)
2471             ),
2472             TP_fast_assign(WIPHY_ASSIGN;
2473                            NETDEV_ASSIGN;
2474                            MAC_ASSIGN(bssid, params->bssid);
2475                            memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
2476                            memcpy(__entry->ssid, params->ssid.ssid,
2477                                   params->ssid.ssid_len);
2478                            __entry->status = params->status;
2479             ),
2480             TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
2481                       ", ssid: %s, status: %u", WIPHY_PR_ARG, NETDEV_PR_ARG,
2482                       __entry->bssid, __entry->ssid, __entry->status)
2483 );
2484
2485 TRACE_EVENT(rdev_start_radar_detection,
2486         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2487                  struct cfg80211_chan_def *chandef,
2488                  u32 cac_time_ms),
2489         TP_ARGS(wiphy, netdev, chandef, cac_time_ms),
2490         TP_STRUCT__entry(
2491                 WIPHY_ENTRY
2492                 NETDEV_ENTRY
2493                 CHAN_DEF_ENTRY
2494                 __field(u32, cac_time_ms)
2495         ),
2496         TP_fast_assign(
2497                 WIPHY_ASSIGN;
2498                 NETDEV_ASSIGN;
2499                 CHAN_DEF_ASSIGN(chandef);
2500                 __entry->cac_time_ms = cac_time_ms;
2501         ),
2502         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT
2503                   ", cac_time_ms=%u",
2504                   WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
2505                   __entry->cac_time_ms)
2506 );
2507
2508 TRACE_EVENT(rdev_set_mcast_rate,
2509         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2510                  int *mcast_rate),
2511         TP_ARGS(wiphy, netdev, mcast_rate),
2512         TP_STRUCT__entry(
2513                 WIPHY_ENTRY
2514                 NETDEV_ENTRY
2515                 __array(int, mcast_rate, NUM_NL80211_BANDS)
2516         ),
2517         TP_fast_assign(
2518                 WIPHY_ASSIGN;
2519                 NETDEV_ASSIGN;
2520                 memcpy(__entry->mcast_rate, mcast_rate,
2521                        sizeof(int) * NUM_NL80211_BANDS);
2522         ),
2523         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", "
2524                   "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 6GHz=0x%x, 60GHz=0x%x]",
2525                   WIPHY_PR_ARG, NETDEV_PR_ARG,
2526                   __entry->mcast_rate[NL80211_BAND_2GHZ],
2527                   __entry->mcast_rate[NL80211_BAND_5GHZ],
2528                   __entry->mcast_rate[NL80211_BAND_6GHZ],
2529                   __entry->mcast_rate[NL80211_BAND_60GHZ])
2530 );
2531
2532 TRACE_EVENT(rdev_set_coalesce,
2533         TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce),
2534         TP_ARGS(wiphy, coalesce),
2535         TP_STRUCT__entry(
2536                 WIPHY_ENTRY
2537                 __field(int, n_rules)
2538         ),
2539         TP_fast_assign(
2540                 WIPHY_ASSIGN;
2541                 __entry->n_rules = coalesce ? coalesce->n_rules : 0;
2542         ),
2543         TP_printk(WIPHY_PR_FMT ", n_rules=%d",
2544                   WIPHY_PR_ARG, __entry->n_rules)
2545 );
2546
2547 DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan,
2548         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2549         TP_ARGS(wiphy, wdev)
2550 );
2551
2552 TRACE_EVENT(rdev_set_multicast_to_unicast,
2553         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2554                  const bool enabled),
2555         TP_ARGS(wiphy, netdev, enabled),
2556         TP_STRUCT__entry(
2557                 WIPHY_ENTRY
2558                 NETDEV_ENTRY
2559                 __field(bool, enabled)
2560         ),
2561         TP_fast_assign(
2562                 WIPHY_ASSIGN;
2563                 NETDEV_ASSIGN;
2564                 __entry->enabled = enabled;
2565         ),
2566         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", unicast: %s",
2567                   WIPHY_PR_ARG, NETDEV_PR_ARG,
2568                   BOOL_TO_STR(__entry->enabled))
2569 );
2570
2571 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_txq_stats,
2572         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2573         TP_ARGS(wiphy, wdev)
2574 );
2575
2576 TRACE_EVENT(rdev_get_ftm_responder_stats,
2577         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2578                  struct cfg80211_ftm_responder_stats *ftm_stats),
2579
2580         TP_ARGS(wiphy, netdev, ftm_stats),
2581
2582         TP_STRUCT__entry(
2583                 WIPHY_ENTRY
2584                 NETDEV_ENTRY
2585                 __field(u64, timestamp)
2586                 __field(u32, success_num)
2587                 __field(u32, partial_num)
2588                 __field(u32, failed_num)
2589                 __field(u32, asap_num)
2590                 __field(u32, non_asap_num)
2591                 __field(u64, duration)
2592                 __field(u32, unknown_triggers)
2593                 __field(u32, reschedule)
2594                 __field(u32, out_of_window)
2595         ),
2596
2597         TP_fast_assign(
2598                 WIPHY_ASSIGN;
2599                 NETDEV_ASSIGN;
2600                 __entry->success_num = ftm_stats->success_num;
2601                 __entry->partial_num = ftm_stats->partial_num;
2602                 __entry->failed_num = ftm_stats->failed_num;
2603                 __entry->asap_num = ftm_stats->asap_num;
2604                 __entry->non_asap_num = ftm_stats->non_asap_num;
2605                 __entry->duration = ftm_stats->total_duration_ms;
2606                 __entry->unknown_triggers = ftm_stats->unknown_triggers_num;
2607                 __entry->reschedule = ftm_stats->reschedule_requests_num;
2608                 __entry->out_of_window = ftm_stats->out_of_window_triggers_num;
2609         ),
2610
2611         TP_printk(WIPHY_PR_FMT "Ftm responder stats: success %u, partial %u, "
2612                 "failed %u, asap %u, non asap %u, total duration %llu, unknown "
2613                 "triggers %u, rescheduled %u, out of window %u", WIPHY_PR_ARG,
2614                 __entry->success_num, __entry->partial_num, __entry->failed_num,
2615                 __entry->asap_num, __entry->non_asap_num, __entry->duration,
2616                 __entry->unknown_triggers, __entry->reschedule,
2617                 __entry->out_of_window)
2618 );
2619
2620 DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_start_pmsr,
2621         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
2622         TP_ARGS(wiphy, wdev, cookie)
2623 );
2624
2625 DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_abort_pmsr,
2626         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
2627         TP_ARGS(wiphy, wdev, cookie)
2628 );
2629
2630 TRACE_EVENT(rdev_set_fils_aad,
2631         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2632                  struct cfg80211_fils_aad *fils_aad),
2633         TP_ARGS(wiphy, netdev, fils_aad),
2634         TP_STRUCT__entry(WIPHY_ENTRY
2635                 NETDEV_ENTRY
2636                 __array(u8, macaddr, ETH_ALEN)
2637                 __field(u8, kek_len)
2638         ),
2639         TP_fast_assign(WIPHY_ASSIGN;
2640                 NETDEV_ASSIGN;
2641                 FILS_AAD_ASSIGN(fils_aad);
2642         ),
2643         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " FILS_AAD_PR_FMT,
2644                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr,
2645                   __entry->kek_len)
2646 );
2647
2648 /*************************************************************
2649  *           cfg80211 exported functions traces              *
2650  *************************************************************/
2651
2652 TRACE_EVENT(cfg80211_return_bool,
2653         TP_PROTO(bool ret),
2654         TP_ARGS(ret),
2655         TP_STRUCT__entry(
2656                 __field(bool, ret)
2657         ),
2658         TP_fast_assign(
2659                 __entry->ret = ret;
2660         ),
2661         TP_printk("returned %s", BOOL_TO_STR(__entry->ret))
2662 );
2663
2664 DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt,
2665         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2666         TP_ARGS(netdev, macaddr),
2667         TP_STRUCT__entry(
2668                 NETDEV_ENTRY
2669                 MAC_ENTRY(macaddr)
2670         ),
2671         TP_fast_assign(
2672                 NETDEV_ASSIGN;
2673                 MAC_ASSIGN(macaddr, macaddr);
2674         ),
2675         TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
2676                   NETDEV_PR_ARG, MAC_PR_ARG(macaddr))
2677 );
2678
2679 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate,
2680         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2681         TP_ARGS(netdev, macaddr)
2682 );
2683
2684 DECLARE_EVENT_CLASS(netdev_evt_only,
2685         TP_PROTO(struct net_device *netdev),
2686         TP_ARGS(netdev),
2687         TP_STRUCT__entry(
2688                 NETDEV_ENTRY
2689         ),
2690         TP_fast_assign(
2691                 NETDEV_ASSIGN;
2692         ),
2693         TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG)
2694 );
2695
2696 DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth,
2697         TP_PROTO(struct net_device *netdev),
2698         TP_ARGS(netdev)
2699 );
2700
2701 TRACE_EVENT(cfg80211_send_rx_assoc,
2702         TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss),
2703         TP_ARGS(netdev, bss),
2704         TP_STRUCT__entry(
2705                 NETDEV_ENTRY
2706                 MAC_ENTRY(bssid)
2707                 CHAN_ENTRY
2708         ),
2709         TP_fast_assign(
2710                 NETDEV_ASSIGN;
2711                 MAC_ASSIGN(bssid, bss->bssid);
2712                 CHAN_ASSIGN(bss->channel);
2713         ),
2714         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", " CHAN_PR_FMT,
2715                   NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
2716 );
2717
2718 DECLARE_EVENT_CLASS(netdev_frame_event,
2719         TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
2720         TP_ARGS(netdev, buf, len),
2721         TP_STRUCT__entry(
2722                 NETDEV_ENTRY
2723                 __dynamic_array(u8, frame, len)
2724         ),
2725         TP_fast_assign(
2726                 NETDEV_ASSIGN;
2727                 memcpy(__get_dynamic_array(frame), buf, len);
2728         ),
2729         TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x",
2730                   NETDEV_PR_ARG,
2731                   le16_to_cpup((__le16 *)__get_dynamic_array(frame)))
2732 );
2733
2734 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt,
2735         TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
2736         TP_ARGS(netdev, buf, len)
2737 );
2738
2739 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt,
2740         TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
2741         TP_ARGS(netdev, buf, len)
2742 );
2743
2744 TRACE_EVENT(cfg80211_tx_mlme_mgmt,
2745         TP_PROTO(struct net_device *netdev, const u8 *buf, int len,
2746                  bool reconnect),
2747         TP_ARGS(netdev, buf, len, reconnect),
2748         TP_STRUCT__entry(
2749                 NETDEV_ENTRY
2750                 __dynamic_array(u8, frame, len)
2751                 __field(int, reconnect)
2752         ),
2753         TP_fast_assign(
2754                 NETDEV_ASSIGN;
2755                 memcpy(__get_dynamic_array(frame), buf, len);
2756                 __entry->reconnect = reconnect;
2757         ),
2758         TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x reconnect:%d",
2759                   NETDEV_PR_ARG,
2760                   le16_to_cpup((__le16 *)__get_dynamic_array(frame)),
2761                   __entry->reconnect)
2762 );
2763
2764 DECLARE_EVENT_CLASS(netdev_mac_evt,
2765         TP_PROTO(struct net_device *netdev, const u8 *mac),
2766         TP_ARGS(netdev, mac),
2767         TP_STRUCT__entry(
2768                 NETDEV_ENTRY
2769                 MAC_ENTRY(mac)
2770         ),
2771         TP_fast_assign(
2772                 NETDEV_ASSIGN;
2773                 MAC_ASSIGN(mac, mac)
2774         ),
2775         TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
2776                   NETDEV_PR_ARG, MAC_PR_ARG(mac))
2777 );
2778
2779 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout,
2780         TP_PROTO(struct net_device *netdev, const u8 *mac),
2781         TP_ARGS(netdev, mac)
2782 );
2783
2784 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout,
2785         TP_PROTO(struct net_device *netdev, const u8 *mac),
2786         TP_ARGS(netdev, mac)
2787 );
2788
2789 TRACE_EVENT(cfg80211_michael_mic_failure,
2790         TP_PROTO(struct net_device *netdev, const u8 *addr,
2791                  enum nl80211_key_type key_type, int key_id, const u8 *tsc),
2792         TP_ARGS(netdev, addr, key_type, key_id, tsc),
2793         TP_STRUCT__entry(
2794                 NETDEV_ENTRY
2795                 MAC_ENTRY(addr)
2796                 __field(enum nl80211_key_type, key_type)
2797                 __field(int, key_id)
2798                 __array(u8, tsc, 6)
2799         ),
2800         TP_fast_assign(
2801                 NETDEV_ASSIGN;
2802                 MAC_ASSIGN(addr, addr);
2803                 __entry->key_type = key_type;
2804                 __entry->key_id = key_id;
2805                 if (tsc)
2806                         memcpy(__entry->tsc, tsc, 6);
2807         ),
2808         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", key type: %d, key id: %d, tsc: %pm",
2809                   NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->key_type,
2810                   __entry->key_id, __entry->tsc)
2811 );
2812
2813 TRACE_EVENT(cfg80211_ready_on_channel,
2814         TP_PROTO(struct wireless_dev *wdev, u64 cookie,
2815                  struct ieee80211_channel *chan,
2816                  unsigned int duration),
2817         TP_ARGS(wdev, cookie, chan, duration),
2818         TP_STRUCT__entry(
2819                 WDEV_ENTRY
2820                 __field(u64, cookie)
2821                 CHAN_ENTRY
2822                 __field(unsigned int, duration)
2823         ),
2824         TP_fast_assign(
2825                 WDEV_ASSIGN;
2826                 __entry->cookie = cookie;
2827                 CHAN_ASSIGN(chan);
2828                 __entry->duration = duration;
2829         ),
2830         TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u",
2831                   WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG,
2832                   __entry->duration)
2833 );
2834
2835 TRACE_EVENT(cfg80211_ready_on_channel_expired,
2836         TP_PROTO(struct wireless_dev *wdev, u64 cookie,
2837                  struct ieee80211_channel *chan),
2838         TP_ARGS(wdev, cookie, chan),
2839         TP_STRUCT__entry(
2840                 WDEV_ENTRY
2841                 __field(u64, cookie)
2842                 CHAN_ENTRY
2843         ),
2844         TP_fast_assign(
2845                 WDEV_ASSIGN;
2846                 __entry->cookie = cookie;
2847                 CHAN_ASSIGN(chan);
2848         ),
2849         TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT,
2850                   WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG)
2851 );
2852
2853 TRACE_EVENT(cfg80211_tx_mgmt_expired,
2854         TP_PROTO(struct wireless_dev *wdev, u64 cookie,
2855                  struct ieee80211_channel *chan),
2856         TP_ARGS(wdev, cookie, chan),
2857         TP_STRUCT__entry(
2858                 WDEV_ENTRY
2859                 __field(u64, cookie)
2860                 CHAN_ENTRY
2861         ),
2862         TP_fast_assign(
2863                 WDEV_ASSIGN;
2864                 __entry->cookie = cookie;
2865                 CHAN_ASSIGN(chan);
2866         ),
2867         TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT,
2868                   WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG)
2869 );
2870
2871 TRACE_EVENT(cfg80211_new_sta,
2872         TP_PROTO(struct net_device *netdev, const u8 *mac_addr,
2873                  struct station_info *sinfo),
2874         TP_ARGS(netdev, mac_addr, sinfo),
2875         TP_STRUCT__entry(
2876                 NETDEV_ENTRY
2877                 MAC_ENTRY(mac_addr)
2878                 SINFO_ENTRY
2879         ),
2880         TP_fast_assign(
2881                 NETDEV_ASSIGN;
2882                 MAC_ASSIGN(mac_addr, mac_addr);
2883                 SINFO_ASSIGN;
2884         ),
2885         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT,
2886                   NETDEV_PR_ARG, MAC_PR_ARG(mac_addr))
2887 );
2888
2889 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta,
2890         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2891         TP_ARGS(netdev, macaddr)
2892 );
2893
2894 TRACE_EVENT(cfg80211_rx_mgmt,
2895         TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm),
2896         TP_ARGS(wdev, freq, sig_dbm),
2897         TP_STRUCT__entry(
2898                 WDEV_ENTRY
2899                 __field(int, freq)
2900                 __field(int, sig_dbm)
2901         ),
2902         TP_fast_assign(
2903                 WDEV_ASSIGN;
2904                 __entry->freq = freq;
2905                 __entry->sig_dbm = sig_dbm;
2906         ),
2907         TP_printk(WDEV_PR_FMT ", freq: "KHZ_F", sig dbm: %d",
2908                   WDEV_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm)
2909 );
2910
2911 TRACE_EVENT(cfg80211_mgmt_tx_status,
2912         TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack),
2913         TP_ARGS(wdev, cookie, ack),
2914         TP_STRUCT__entry(
2915                 WDEV_ENTRY
2916                 __field(u64, cookie)
2917                 __field(bool, ack)
2918         ),
2919         TP_fast_assign(
2920                 WDEV_ASSIGN;
2921                 __entry->cookie = cookie;
2922                 __entry->ack = ack;
2923         ),
2924         TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s",
2925                   WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack))
2926 );
2927
2928 TRACE_EVENT(cfg80211_control_port_tx_status,
2929         TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack),
2930         TP_ARGS(wdev, cookie, ack),
2931         TP_STRUCT__entry(
2932                 WDEV_ENTRY
2933                 __field(u64, cookie)
2934                 __field(bool, ack)
2935         ),
2936         TP_fast_assign(
2937                 WDEV_ASSIGN;
2938                 __entry->cookie = cookie;
2939                 __entry->ack = ack;
2940         ),
2941         TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s",
2942                   WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack))
2943 );
2944
2945 TRACE_EVENT(cfg80211_rx_control_port,
2946         TP_PROTO(struct net_device *netdev, struct sk_buff *skb,
2947                  bool unencrypted),
2948         TP_ARGS(netdev, skb, unencrypted),
2949         TP_STRUCT__entry(
2950                 NETDEV_ENTRY
2951                 __field(int, len)
2952                 MAC_ENTRY(from)
2953                 __field(u16, proto)
2954                 __field(bool, unencrypted)
2955         ),
2956         TP_fast_assign(
2957                 NETDEV_ASSIGN;
2958                 __entry->len = skb->len;
2959                 MAC_ASSIGN(from, eth_hdr(skb)->h_source);
2960                 __entry->proto = be16_to_cpu(skb->protocol);
2961                 __entry->unencrypted = unencrypted;
2962         ),
2963         TP_printk(NETDEV_PR_FMT ", len=%d, " MAC_PR_FMT ", proto: 0x%x, unencrypted: %s",
2964                   NETDEV_PR_ARG, __entry->len, MAC_PR_ARG(from),
2965                   __entry->proto, BOOL_TO_STR(__entry->unencrypted))
2966 );
2967
2968 TRACE_EVENT(cfg80211_cqm_rssi_notify,
2969         TP_PROTO(struct net_device *netdev,
2970                  enum nl80211_cqm_rssi_threshold_event rssi_event,
2971                  s32 rssi_level),
2972         TP_ARGS(netdev, rssi_event, rssi_level),
2973         TP_STRUCT__entry(
2974                 NETDEV_ENTRY
2975                 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event)
2976                 __field(s32, rssi_level)
2977         ),
2978         TP_fast_assign(
2979                 NETDEV_ASSIGN;
2980                 __entry->rssi_event = rssi_event;
2981                 __entry->rssi_level = rssi_level;
2982         ),
2983         TP_printk(NETDEV_PR_FMT ", rssi event: %d, level: %d",
2984                   NETDEV_PR_ARG, __entry->rssi_event, __entry->rssi_level)
2985 );
2986
2987 TRACE_EVENT(cfg80211_reg_can_beacon,
2988         TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef,
2989                  enum nl80211_iftype iftype, bool check_no_ir),
2990         TP_ARGS(wiphy, chandef, iftype, check_no_ir),
2991         TP_STRUCT__entry(
2992                 WIPHY_ENTRY
2993                 CHAN_DEF_ENTRY
2994                 __field(enum nl80211_iftype, iftype)
2995                 __field(bool, check_no_ir)
2996         ),
2997         TP_fast_assign(
2998                 WIPHY_ASSIGN;
2999                 CHAN_DEF_ASSIGN(chandef);
3000                 __entry->iftype = iftype;
3001                 __entry->check_no_ir = check_no_ir;
3002         ),
3003         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d check_no_ir=%s",
3004                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype,
3005                   BOOL_TO_STR(__entry->check_no_ir))
3006 );
3007
3008 TRACE_EVENT(cfg80211_chandef_dfs_required,
3009         TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef),
3010         TP_ARGS(wiphy, chandef),
3011         TP_STRUCT__entry(
3012                 WIPHY_ENTRY
3013                 CHAN_DEF_ENTRY
3014         ),
3015         TP_fast_assign(
3016                 WIPHY_ASSIGN;
3017                 CHAN_DEF_ASSIGN(chandef);
3018         ),
3019         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
3020                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
3021 );
3022
3023 TRACE_EVENT(cfg80211_ch_switch_notify,
3024         TP_PROTO(struct net_device *netdev,
3025                  struct cfg80211_chan_def *chandef),
3026         TP_ARGS(netdev, chandef),
3027         TP_STRUCT__entry(
3028                 NETDEV_ENTRY
3029                 CHAN_DEF_ENTRY
3030         ),
3031         TP_fast_assign(
3032                 NETDEV_ASSIGN;
3033                 CHAN_DEF_ASSIGN(chandef);
3034         ),
3035         TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
3036                   NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
3037 );
3038
3039 TRACE_EVENT(cfg80211_ch_switch_started_notify,
3040         TP_PROTO(struct net_device *netdev,
3041                  struct cfg80211_chan_def *chandef),
3042         TP_ARGS(netdev, chandef),
3043         TP_STRUCT__entry(
3044                 NETDEV_ENTRY
3045                 CHAN_DEF_ENTRY
3046         ),
3047         TP_fast_assign(
3048                 NETDEV_ASSIGN;
3049                 CHAN_DEF_ASSIGN(chandef);
3050         ),
3051         TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
3052                   NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
3053 );
3054
3055 TRACE_EVENT(cfg80211_radar_event,
3056         TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef,
3057                  bool offchan),
3058         TP_ARGS(wiphy, chandef, offchan),
3059         TP_STRUCT__entry(
3060                 WIPHY_ENTRY
3061                 CHAN_DEF_ENTRY
3062                 __field(bool, offchan)
3063         ),
3064         TP_fast_assign(
3065                 WIPHY_ASSIGN;
3066                 CHAN_DEF_ASSIGN(chandef);
3067                 __entry->offchan = offchan;
3068         ),
3069         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", offchan %d",
3070                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->offchan)
3071 );
3072
3073 TRACE_EVENT(cfg80211_cac_event,
3074         TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt),
3075         TP_ARGS(netdev, evt),
3076         TP_STRUCT__entry(
3077                 NETDEV_ENTRY
3078                 __field(enum nl80211_radar_event, evt)
3079         ),
3080         TP_fast_assign(
3081                 NETDEV_ASSIGN;
3082                 __entry->evt = evt;
3083         ),
3084         TP_printk(NETDEV_PR_FMT ",  event: %d",
3085                   NETDEV_PR_ARG, __entry->evt)
3086 );
3087
3088 DECLARE_EVENT_CLASS(cfg80211_rx_evt,
3089         TP_PROTO(struct net_device *netdev, const u8 *addr),
3090         TP_ARGS(netdev, addr),
3091         TP_STRUCT__entry(
3092                 NETDEV_ENTRY
3093                 MAC_ENTRY(addr)
3094         ),
3095         TP_fast_assign(
3096                 NETDEV_ASSIGN;
3097                 MAC_ASSIGN(addr, addr);
3098         ),
3099         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr))
3100 );
3101
3102 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame,
3103         TP_PROTO(struct net_device *netdev, const u8 *addr),
3104         TP_ARGS(netdev, addr)
3105 );
3106
3107 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame,
3108         TP_PROTO(struct net_device *netdev, const u8 *addr),
3109         TP_ARGS(netdev, addr)
3110 );
3111
3112 TRACE_EVENT(cfg80211_ibss_joined,
3113         TP_PROTO(struct net_device *netdev, const u8 *bssid,
3114                  struct ieee80211_channel *channel),
3115         TP_ARGS(netdev, bssid, channel),
3116         TP_STRUCT__entry(
3117                 NETDEV_ENTRY
3118                 MAC_ENTRY(bssid)
3119                 CHAN_ENTRY
3120         ),
3121         TP_fast_assign(
3122                 NETDEV_ASSIGN;
3123                 MAC_ASSIGN(bssid, bssid);
3124                 CHAN_ASSIGN(channel);
3125         ),
3126         TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT,
3127                   NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
3128 );
3129
3130 TRACE_EVENT(cfg80211_probe_status,
3131         TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie,
3132                  bool acked),
3133         TP_ARGS(netdev, addr, cookie, acked),
3134         TP_STRUCT__entry(
3135                 NETDEV_ENTRY
3136                 MAC_ENTRY(addr)
3137                 __field(u64, cookie)
3138                 __field(bool, acked)
3139         ),
3140         TP_fast_assign(
3141                 NETDEV_ASSIGN;
3142                 MAC_ASSIGN(addr, addr);
3143                 __entry->cookie = cookie;
3144                 __entry->acked = acked;
3145         ),
3146         TP_printk(NETDEV_PR_FMT " addr:" MAC_PR_FMT ", cookie: %llu, acked: %s",
3147                   NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie,
3148                   BOOL_TO_STR(__entry->acked))
3149 );
3150
3151 TRACE_EVENT(cfg80211_cqm_pktloss_notify,
3152         TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets),
3153         TP_ARGS(netdev, peer, num_packets),
3154         TP_STRUCT__entry(
3155                 NETDEV_ENTRY
3156                 MAC_ENTRY(peer)
3157                 __field(u32, num_packets)
3158         ),
3159         TP_fast_assign(
3160                 NETDEV_ASSIGN;
3161                 MAC_ASSIGN(peer, peer);
3162                 __entry->num_packets = num_packets;
3163         ),
3164         TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u",
3165                   NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets)
3166 );
3167
3168 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify,
3169         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
3170         TP_ARGS(netdev, macaddr)
3171 );
3172
3173 TRACE_EVENT(cfg80211_pmksa_candidate_notify,
3174         TP_PROTO(struct net_device *netdev, int index, const u8 *bssid,
3175                  bool preauth),
3176         TP_ARGS(netdev, index, bssid, preauth),
3177         TP_STRUCT__entry(
3178                 NETDEV_ENTRY
3179                 __field(int, index)
3180                 MAC_ENTRY(bssid)
3181                 __field(bool, preauth)
3182         ),
3183         TP_fast_assign(
3184                 NETDEV_ASSIGN;
3185                 __entry->index = index;
3186                 MAC_ASSIGN(bssid, bssid);
3187                 __entry->preauth = preauth;
3188         ),
3189         TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s",
3190                   NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid),
3191                   BOOL_TO_STR(__entry->preauth))
3192 );
3193
3194 TRACE_EVENT(cfg80211_report_obss_beacon,
3195         TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len,
3196                  int freq, int sig_dbm),
3197         TP_ARGS(wiphy, frame, len, freq, sig_dbm),
3198         TP_STRUCT__entry(
3199                 WIPHY_ENTRY
3200                 __field(int, freq)
3201                 __field(int, sig_dbm)
3202         ),
3203         TP_fast_assign(
3204                 WIPHY_ASSIGN;
3205                 __entry->freq = freq;
3206                 __entry->sig_dbm = sig_dbm;
3207         ),
3208         TP_printk(WIPHY_PR_FMT ", freq: "KHZ_F", sig_dbm: %d",
3209                   WIPHY_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm)
3210 );
3211
3212 TRACE_EVENT(cfg80211_tdls_oper_request,
3213         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer,
3214                  enum nl80211_tdls_operation oper, u16 reason_code),
3215         TP_ARGS(wiphy, netdev, peer, oper, reason_code),
3216         TP_STRUCT__entry(
3217                 WIPHY_ENTRY
3218                 NETDEV_ENTRY
3219                 MAC_ENTRY(peer)
3220                 __field(enum nl80211_tdls_operation, oper)
3221                 __field(u16, reason_code)
3222         ),
3223         TP_fast_assign(
3224                 WIPHY_ASSIGN;
3225                 NETDEV_ASSIGN;
3226                 MAC_ASSIGN(peer, peer);
3227                 __entry->oper = oper;
3228                 __entry->reason_code = reason_code;
3229         ),
3230         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", oper: %d, reason_code %u",
3231                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper,
3232                   __entry->reason_code)
3233         );
3234
3235 TRACE_EVENT(cfg80211_scan_done,
3236         TP_PROTO(struct cfg80211_scan_request *request,
3237                  struct cfg80211_scan_info *info),
3238         TP_ARGS(request, info),
3239         TP_STRUCT__entry(
3240                 __field(u32, n_channels)
3241                 __dynamic_array(u8, ie, request ? request->ie_len : 0)
3242                 __array(u32, rates, NUM_NL80211_BANDS)
3243                 __field(u32, wdev_id)
3244                 MAC_ENTRY(wiphy_mac)
3245                 __field(bool, no_cck)
3246                 __field(bool, aborted)
3247                 __field(u64, scan_start_tsf)
3248                 MAC_ENTRY(tsf_bssid)
3249         ),
3250         TP_fast_assign(
3251                 if (request) {
3252                         memcpy(__get_dynamic_array(ie), request->ie,
3253                                request->ie_len);
3254                         memcpy(__entry->rates, request->rates,
3255                                NUM_NL80211_BANDS);
3256                         __entry->wdev_id = request->wdev ?
3257                                         request->wdev->identifier : 0;
3258                         if (request->wiphy)
3259                                 MAC_ASSIGN(wiphy_mac,
3260                                            request->wiphy->perm_addr);
3261                         __entry->no_cck = request->no_cck;
3262                 }
3263                 if (info) {
3264                         __entry->aborted = info->aborted;
3265                         __entry->scan_start_tsf = info->scan_start_tsf;
3266                         MAC_ASSIGN(tsf_bssid, info->tsf_bssid);
3267                 }
3268         ),
3269         TP_printk("aborted: %s, scan start (TSF): %llu, tsf_bssid: " MAC_PR_FMT,
3270                   BOOL_TO_STR(__entry->aborted),
3271                   (unsigned long long)__entry->scan_start_tsf,
3272                   MAC_PR_ARG(tsf_bssid))
3273 );
3274
3275 DECLARE_EVENT_CLASS(wiphy_id_evt,
3276         TP_PROTO(struct wiphy *wiphy, u64 id),
3277         TP_ARGS(wiphy, id),
3278         TP_STRUCT__entry(
3279                 WIPHY_ENTRY
3280                 __field(u64, id)
3281         ),
3282         TP_fast_assign(
3283                 WIPHY_ASSIGN;
3284                 __entry->id = id;
3285         ),
3286         TP_printk(WIPHY_PR_FMT ", id: %llu", WIPHY_PR_ARG, __entry->id)
3287 );
3288
3289 DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped,
3290         TP_PROTO(struct wiphy *wiphy, u64 id),
3291         TP_ARGS(wiphy, id)
3292 );
3293
3294 DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results,
3295         TP_PROTO(struct wiphy *wiphy, u64 id),
3296         TP_ARGS(wiphy, id)
3297 );
3298
3299 TRACE_EVENT(cfg80211_get_bss,
3300         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
3301                  const u8 *bssid, const u8 *ssid, size_t ssid_len,
3302                  enum ieee80211_bss_type bss_type,
3303                  enum ieee80211_privacy privacy),
3304         TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy),
3305         TP_STRUCT__entry(
3306                 WIPHY_ENTRY
3307                 CHAN_ENTRY
3308                 MAC_ENTRY(bssid)
3309                 __dynamic_array(u8, ssid, ssid_len)
3310                 __field(enum ieee80211_bss_type, bss_type)
3311                 __field(enum ieee80211_privacy, privacy)
3312         ),
3313         TP_fast_assign(
3314                 WIPHY_ASSIGN;
3315                 CHAN_ASSIGN(channel);
3316                 MAC_ASSIGN(bssid, bssid);
3317                 memcpy(__get_dynamic_array(ssid), ssid, ssid_len);
3318                 __entry->bss_type = bss_type;
3319                 __entry->privacy = privacy;
3320         ),
3321         TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", " MAC_PR_FMT
3322                   ", buf: %#.2x, bss_type: %d, privacy: %d",
3323                   WIPHY_PR_ARG, CHAN_PR_ARG, MAC_PR_ARG(bssid),
3324                   ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type,
3325                   __entry->privacy)
3326 );
3327
3328 TRACE_EVENT(cfg80211_inform_bss_frame,
3329         TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data,
3330                  struct ieee80211_mgmt *mgmt, size_t len),
3331         TP_ARGS(wiphy, data, mgmt, len),
3332         TP_STRUCT__entry(
3333                 WIPHY_ENTRY
3334                 CHAN_ENTRY
3335                 __field(enum nl80211_bss_scan_width, scan_width)
3336                 __dynamic_array(u8, mgmt, len)
3337                 __field(s32, signal)
3338                 __field(u64, ts_boottime)
3339                 __field(u64, parent_tsf)
3340                 MAC_ENTRY(parent_bssid)
3341         ),
3342         TP_fast_assign(
3343                 WIPHY_ASSIGN;
3344                 CHAN_ASSIGN(data->chan);
3345                 __entry->scan_width = data->scan_width;
3346                 if (mgmt)
3347                         memcpy(__get_dynamic_array(mgmt), mgmt, len);
3348                 __entry->signal = data->signal;
3349                 __entry->ts_boottime = data->boottime_ns;
3350                 __entry->parent_tsf = data->parent_tsf;
3351                 MAC_ASSIGN(parent_bssid, data->parent_bssid);
3352         ),
3353         TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT
3354                   "(scan_width: %d) signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: "
3355                   MAC_PR_FMT, WIPHY_PR_ARG, CHAN_PR_ARG, __entry->scan_width,
3356                   __entry->signal, (unsigned long long)__entry->ts_boottime,
3357                   (unsigned long long)__entry->parent_tsf,
3358                   MAC_PR_ARG(parent_bssid))
3359 );
3360
3361 DECLARE_EVENT_CLASS(cfg80211_bss_evt,
3362         TP_PROTO(struct cfg80211_bss *pub),
3363         TP_ARGS(pub),
3364         TP_STRUCT__entry(
3365                 MAC_ENTRY(bssid)
3366                 CHAN_ENTRY
3367         ),
3368         TP_fast_assign(
3369                 MAC_ASSIGN(bssid, pub->bssid);
3370                 CHAN_ASSIGN(pub->channel);
3371         ),
3372         TP_printk(MAC_PR_FMT ", " CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG)
3373 );
3374
3375 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss,
3376         TP_PROTO(struct cfg80211_bss *pub),
3377         TP_ARGS(pub)
3378 );
3379
3380 TRACE_EVENT(cfg80211_return_uint,
3381         TP_PROTO(unsigned int ret),
3382         TP_ARGS(ret),
3383         TP_STRUCT__entry(
3384                 __field(unsigned int, ret)
3385         ),
3386         TP_fast_assign(
3387                 __entry->ret = ret;
3388         ),
3389         TP_printk("ret: %d", __entry->ret)
3390 );
3391
3392 TRACE_EVENT(cfg80211_return_u32,
3393         TP_PROTO(u32 ret),
3394         TP_ARGS(ret),
3395         TP_STRUCT__entry(
3396                 __field(u32, ret)
3397         ),
3398         TP_fast_assign(
3399                 __entry->ret = ret;
3400         ),
3401         TP_printk("ret: %u", __entry->ret)
3402 );
3403
3404 TRACE_EVENT(cfg80211_report_wowlan_wakeup,
3405         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3406                  struct cfg80211_wowlan_wakeup *wakeup),
3407         TP_ARGS(wiphy, wdev, wakeup),
3408         TP_STRUCT__entry(
3409                 WIPHY_ENTRY
3410                 WDEV_ENTRY
3411                 __field(bool, non_wireless)
3412                 __field(bool, disconnect)
3413                 __field(bool, magic_pkt)
3414                 __field(bool, gtk_rekey_failure)
3415                 __field(bool, eap_identity_req)
3416                 __field(bool, four_way_handshake)
3417                 __field(bool, rfkill_release)
3418                 __field(s32, pattern_idx)
3419                 __field(u32, packet_len)
3420                 __dynamic_array(u8, packet,
3421                                 wakeup ? wakeup->packet_present_len : 0)
3422         ),
3423         TP_fast_assign(
3424                 WIPHY_ASSIGN;
3425                 WDEV_ASSIGN;
3426                 __entry->non_wireless = !wakeup;
3427                 __entry->disconnect = wakeup ? wakeup->disconnect : false;
3428                 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false;
3429                 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false;
3430                 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false;
3431                 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false;
3432                 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false;
3433                 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false;
3434                 __entry->packet_len = wakeup ? wakeup->packet_len : false;
3435                 if (wakeup && wakeup->packet && wakeup->packet_present_len)
3436                         memcpy(__get_dynamic_array(packet), wakeup->packet,
3437                                wakeup->packet_present_len);
3438         ),
3439         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
3440 );
3441
3442 TRACE_EVENT(cfg80211_ft_event,
3443         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3444                  struct cfg80211_ft_event_params *ft_event),
3445         TP_ARGS(wiphy, netdev, ft_event),
3446         TP_STRUCT__entry(
3447                 WIPHY_ENTRY
3448                 NETDEV_ENTRY
3449                 __dynamic_array(u8, ies, ft_event->ies_len)
3450                 MAC_ENTRY(target_ap)
3451                 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len)
3452         ),
3453         TP_fast_assign(
3454                 WIPHY_ASSIGN;
3455                 NETDEV_ASSIGN;
3456                 if (ft_event->ies)
3457                         memcpy(__get_dynamic_array(ies), ft_event->ies,
3458                                ft_event->ies_len);
3459                 MAC_ASSIGN(target_ap, ft_event->target_ap);
3460                 if (ft_event->ric_ies)
3461                         memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies,
3462                                ft_event->ric_ies_len);
3463         ),
3464         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: " MAC_PR_FMT,
3465                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(target_ap))
3466 );
3467
3468 TRACE_EVENT(cfg80211_stop_iface,
3469         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
3470         TP_ARGS(wiphy, wdev),
3471         TP_STRUCT__entry(
3472                 WIPHY_ENTRY
3473                 WDEV_ENTRY
3474         ),
3475         TP_fast_assign(
3476                 WIPHY_ASSIGN;
3477                 WDEV_ASSIGN;
3478         ),
3479         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
3480                   WIPHY_PR_ARG, WDEV_PR_ARG)
3481 );
3482
3483 TRACE_EVENT(cfg80211_pmsr_report,
3484         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3485                  u64 cookie, const u8 *addr),
3486         TP_ARGS(wiphy, wdev, cookie, addr),
3487         TP_STRUCT__entry(
3488                 WIPHY_ENTRY
3489                 WDEV_ENTRY
3490                 __field(u64, cookie)
3491                 MAC_ENTRY(addr)
3492         ),
3493         TP_fast_assign(
3494                 WIPHY_ASSIGN;
3495                 WDEV_ASSIGN;
3496                 __entry->cookie = cookie;
3497                 MAC_ASSIGN(addr, addr);
3498         ),
3499         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld, " MAC_PR_FMT,
3500                   WIPHY_PR_ARG, WDEV_PR_ARG,
3501                   (unsigned long long)__entry->cookie,
3502                   MAC_PR_ARG(addr))
3503 );
3504
3505 TRACE_EVENT(cfg80211_pmsr_complete,
3506         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
3507         TP_ARGS(wiphy, wdev, cookie),
3508         TP_STRUCT__entry(
3509                 WIPHY_ENTRY
3510                 WDEV_ENTRY
3511                 __field(u64, cookie)
3512         ),
3513         TP_fast_assign(
3514                 WIPHY_ASSIGN;
3515                 WDEV_ASSIGN;
3516                 __entry->cookie = cookie;
3517         ),
3518         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld",
3519                   WIPHY_PR_ARG, WDEV_PR_ARG,
3520                   (unsigned long long)__entry->cookie)
3521 );
3522
3523 TRACE_EVENT(rdev_update_owe_info,
3524             TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3525                      struct cfg80211_update_owe_info *owe_info),
3526             TP_ARGS(wiphy, netdev, owe_info),
3527             TP_STRUCT__entry(WIPHY_ENTRY
3528                              NETDEV_ENTRY
3529                              MAC_ENTRY(peer)
3530                              __field(u16, status)
3531                              __dynamic_array(u8, ie, owe_info->ie_len)),
3532             TP_fast_assign(WIPHY_ASSIGN;
3533                            NETDEV_ASSIGN;
3534                            MAC_ASSIGN(peer, owe_info->peer);
3535                            __entry->status = owe_info->status;
3536                            memcpy(__get_dynamic_array(ie),
3537                                   owe_info->ie, owe_info->ie_len);),
3538             TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT
3539                   " status %d", WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
3540                   __entry->status)
3541 );
3542
3543 TRACE_EVENT(cfg80211_update_owe_info_event,
3544             TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3545                      struct cfg80211_update_owe_info *owe_info),
3546             TP_ARGS(wiphy, netdev, owe_info),
3547             TP_STRUCT__entry(WIPHY_ENTRY
3548                              NETDEV_ENTRY
3549                              MAC_ENTRY(peer)
3550                              __dynamic_array(u8, ie, owe_info->ie_len)),
3551             TP_fast_assign(WIPHY_ASSIGN;
3552                            NETDEV_ASSIGN;
3553                            MAC_ASSIGN(peer, owe_info->peer);
3554                            memcpy(__get_dynamic_array(ie), owe_info->ie,
3555                                   owe_info->ie_len);),
3556             TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT,
3557                       WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
3558 );
3559
3560 TRACE_EVENT(rdev_probe_mesh_link,
3561         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3562                  const u8 *dest, const u8 *buf, size_t len),
3563         TP_ARGS(wiphy, netdev, dest, buf, len),
3564         TP_STRUCT__entry(
3565                 WIPHY_ENTRY
3566                 NETDEV_ENTRY
3567                 MAC_ENTRY(dest)
3568         ),
3569         TP_fast_assign(
3570                 WIPHY_ASSIGN;
3571                 NETDEV_ASSIGN;
3572                 MAC_ASSIGN(dest, dest);
3573         ),
3574         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
3575                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dest))
3576 );
3577
3578 TRACE_EVENT(rdev_set_tid_config,
3579         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3580                  struct cfg80211_tid_config *tid_conf),
3581         TP_ARGS(wiphy, netdev, tid_conf),
3582         TP_STRUCT__entry(
3583                 WIPHY_ENTRY
3584                 NETDEV_ENTRY
3585                 MAC_ENTRY(peer)
3586         ),
3587         TP_fast_assign(
3588                 WIPHY_ASSIGN;
3589                 NETDEV_ASSIGN;
3590                 MAC_ASSIGN(peer, tid_conf->peer);
3591         ),
3592         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT,
3593                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
3594 );
3595
3596 TRACE_EVENT(rdev_reset_tid_config,
3597         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3598                  const u8 *peer, u8 tids),
3599         TP_ARGS(wiphy, netdev, peer, tids),
3600         TP_STRUCT__entry(
3601                 WIPHY_ENTRY
3602                 NETDEV_ENTRY
3603                 MAC_ENTRY(peer)
3604                 __field(u8, tids)
3605         ),
3606         TP_fast_assign(
3607                 WIPHY_ASSIGN;
3608                 NETDEV_ASSIGN;
3609                 MAC_ASSIGN(peer, peer);
3610                 __entry->tids = tids;
3611         ),
3612         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", tids: 0x%x",
3613                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->tids)
3614 );
3615
3616 TRACE_EVENT(rdev_set_sar_specs,
3617         TP_PROTO(struct wiphy *wiphy, struct cfg80211_sar_specs *sar),
3618         TP_ARGS(wiphy, sar),
3619         TP_STRUCT__entry(
3620                 WIPHY_ENTRY
3621                 __field(u16, type)
3622                 __field(u16, num)
3623         ),
3624         TP_fast_assign(
3625                 WIPHY_ASSIGN;
3626                 __entry->type = sar->type;
3627                 __entry->num = sar->num_sub_specs;
3628
3629         ),
3630         TP_printk(WIPHY_PR_FMT ", Set type:%d, num_specs:%d",
3631                   WIPHY_PR_ARG, __entry->type, __entry->num)
3632 );
3633
3634 TRACE_EVENT(rdev_color_change,
3635         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3636                  struct cfg80211_color_change_settings *params),
3637         TP_ARGS(wiphy, netdev, params),
3638         TP_STRUCT__entry(
3639                 WIPHY_ENTRY
3640                 NETDEV_ENTRY
3641                 __field(u8, count)
3642                 __field(u16, bcn_ofs)
3643                 __field(u16, pres_ofs)
3644         ),
3645         TP_fast_assign(
3646                 WIPHY_ASSIGN;
3647                 NETDEV_ASSIGN;
3648                 __entry->count = params->count;
3649                 __entry->bcn_ofs = params->counter_offset_beacon;
3650                 __entry->pres_ofs = params->counter_offset_presp;
3651         ),
3652         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
3653                   ", count: %u",
3654                   WIPHY_PR_ARG, NETDEV_PR_ARG,
3655                   __entry->count)
3656 );
3657
3658 TRACE_EVENT(cfg80211_bss_color_notify,
3659         TP_PROTO(struct net_device *netdev,
3660                  enum nl80211_commands cmd,
3661                  u8 count, u64 color_bitmap),
3662         TP_ARGS(netdev, cmd, count, color_bitmap),
3663         TP_STRUCT__entry(
3664                 NETDEV_ENTRY
3665                 __field(u32, cmd)
3666                 __field(u8, count)
3667                 __field(u64, color_bitmap)
3668         ),
3669         TP_fast_assign(
3670                 NETDEV_ASSIGN;
3671                 __entry->cmd = cmd;
3672                 __entry->count = count;
3673                 __entry->color_bitmap = color_bitmap;
3674         ),
3675         TP_printk(NETDEV_PR_FMT ", cmd: %x, count: %u, bitmap: %llx",
3676                   NETDEV_PR_ARG, __entry->cmd, __entry->count,
3677                   __entry->color_bitmap)
3678 );
3679
3680 TRACE_EVENT(rdev_set_radar_background,
3681         TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef),
3682
3683         TP_ARGS(wiphy, chandef),
3684
3685         TP_STRUCT__entry(
3686                 WIPHY_ENTRY
3687                 CHAN_DEF_ENTRY
3688         ),
3689
3690         TP_fast_assign(
3691                 WIPHY_ASSIGN;
3692                 CHAN_DEF_ASSIGN(chandef)
3693         ),
3694
3695         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
3696                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
3697 );
3698
3699 TRACE_EVENT(cfg80211_assoc_comeback,
3700         TP_PROTO(struct wireless_dev *wdev, const u8 *bssid, u32 timeout),
3701         TP_ARGS(wdev, bssid, timeout),
3702         TP_STRUCT__entry(
3703                 WDEV_ENTRY
3704                 MAC_ENTRY(bssid)
3705                 __field(u32, timeout)
3706         ),
3707         TP_fast_assign(
3708                 WDEV_ASSIGN;
3709                 MAC_ASSIGN(bssid, bssid);
3710                 __entry->timeout = timeout;
3711         ),
3712         TP_printk(WDEV_PR_FMT ", " MAC_PR_FMT ", timeout: %u TUs",
3713                   WDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->timeout)
3714 );
3715
3716 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */
3717
3718 #undef TRACE_INCLUDE_PATH
3719 #define TRACE_INCLUDE_PATH .
3720 #undef TRACE_INCLUDE_FILE
3721 #define TRACE_INCLUDE_FILE trace
3722 #include <trace/define_trace.h>