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