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_ap_update *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->beacon.head_len)
 625                 __dynamic_array(u8, tail, info->beacon.tail_len)
 626                 __dynamic_array(u8, beacon_ies, info->beacon.beacon_ies_len)
 627                 __dynamic_array(u8, proberesp_ies, info->beacon.proberesp_ies_len)
 628                 __dynamic_array(u8, assocresp_ies, info->beacon.assocresp_ies_len)
 629                 __dynamic_array(u8, probe_resp, info->beacon.probe_resp_len)
 630         ),
 631         TP_fast_assign(
 632                 WIPHY_ASSIGN;
 633                 NETDEV_ASSIGN;
 634                 __entry->link_id = info->beacon.link_id;
 635                 if (info->beacon.head)
 636                         memcpy(__get_dynamic_array(head),
 637                                info->beacon.head,
 638                                info->beacon.head_len);
 639                 if (info->beacon.tail)
 640                         memcpy(__get_dynamic_array(tail),
 641                                info->beacon.tail,
 642                                info->beacon.tail_len);
 643                 if (info->beacon.beacon_ies)
 644                         memcpy(__get_dynamic_array(beacon_ies),
 645                                info->beacon.beacon_ies,
 646                                info->beacon.beacon_ies_len);
 647                 if (info->beacon.proberesp_ies)
 648                         memcpy(__get_dynamic_array(proberesp_ies),
 649                                info->beacon.proberesp_ies,
 650                                info->beacon.proberesp_ies_len);
 651                 if (info->beacon.assocresp_ies)
 652                         memcpy(__get_dynamic_array(assocresp_ies),
 653                                info->beacon.assocresp_ies,
 654                                info->beacon.assocresp_ies_len);
 655                 if (info->beacon.probe_resp)
 656                         memcpy(__get_dynamic_array(probe_resp),
 657                                info->beacon.probe_resp,
 658                                info->beacon.probe_resp_len);
 659         ),
 660         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id:%d",
 661                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
 662 );
 663
 664 TRACE_EVENT(rdev_stop_ap,
 665         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 666                  unsigned int link_id),
 667         TP_ARGS(wiphy, netdev, link_id),
 668         TP_STRUCT__entry(
 669                 WIPHY_ENTRY
 670                 NETDEV_ENTRY
 671                 __field(unsigned int, link_id)
 672         ),
 673         TP_fast_assign(
 674                 WIPHY_ASSIGN;
 675                 NETDEV_ASSIGN;
 676                 __entry->link_id = link_id;
 677         ),
 678         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d",
 679                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
 680 );
 681
 682 DECLARE_EVENT_CLASS(wiphy_netdev_evt,
 683         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 684         TP_ARGS(wiphy, netdev),
 685         TP_STRUCT__entry(
 686                 WIPHY_ENTRY
 687                 NETDEV_ENTRY
 688         ),
 689         TP_fast_assign(
 690                 WIPHY_ASSIGN;
 691                 NETDEV_ASSIGN;
 692         ),
 693         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
 694 );
 695
 696 DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data,
 697         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 698         TP_ARGS(wiphy, netdev)
 699 );
 700
 701 DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config,
 702         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 703         TP_ARGS(wiphy, netdev)
 704 );
 705
 706 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh,
 707         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 708         TP_ARGS(wiphy, netdev)
 709 );
 710
 711 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss,
 712         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 713         TP_ARGS(wiphy, netdev)
 714 );
 715
 716 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb,
 717         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 718         TP_ARGS(wiphy, netdev)
 719 );
 720
 721 DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa,
 722         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 723         TP_ARGS(wiphy, netdev)
 724 );
 725
 726 DEFINE_EVENT(wiphy_netdev_evt, rdev_end_cac,
 727              TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 728              TP_ARGS(wiphy, netdev)
 729 );
 730
 731 DECLARE_EVENT_CLASS(station_add_change,
 732         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
 733                  struct station_parameters *params),
 734         TP_ARGS(wiphy, netdev, mac, params),
 735         TP_STRUCT__entry(
 736                 WIPHY_ENTRY
 737                 NETDEV_ENTRY
 738                 MAC_ENTRY(sta_mac)
 739                 __field(u32, sta_flags_mask)
 740                 __field(u32, sta_flags_set)
 741                 __field(u32, sta_modify_mask)
 742                 __field(int, listen_interval)
 743                 __field(u16, capability)
 744                 __field(u16, aid)
 745                 __field(u8, plink_action)
 746                 __field(u8, plink_state)
 747                 __field(u8, uapsd_queues)
 748                 __field(u8, max_sp)
 749                 __field(u8, opmode_notif)
 750                 __field(bool, opmode_notif_used)
 751                 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
 752                 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap))
 753                 __array(char, vlan, IFNAMSIZ)
 754                 __dynamic_array(u8, supported_rates,
 755                                 params->link_sta_params.supported_rates_len)
 756                 __dynamic_array(u8, ext_capab, params->ext_capab_len)
 757                 __dynamic_array(u8, supported_channels,
 758                                 params->supported_channels_len)
 759                 __dynamic_array(u8, supported_oper_classes,
 760                                 params->supported_oper_classes_len)
 761         ),
 762         TP_fast_assign(
 763                 WIPHY_ASSIGN;
 764                 NETDEV_ASSIGN;
 765                 MAC_ASSIGN(sta_mac, mac);
 766                 __entry->sta_flags_mask = params->sta_flags_mask;
 767                 __entry->sta_flags_set = params->sta_flags_set;
 768                 __entry->sta_modify_mask = params->sta_modify_mask;
 769                 __entry->listen_interval = params->listen_interval;
 770                 __entry->aid = params->aid;
 771                 __entry->plink_action = params->plink_action;
 772                 __entry->plink_state = params->plink_state;
 773                 __entry->uapsd_queues = params->uapsd_queues;
 774                 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
 775                 if (params->link_sta_params.ht_capa)
 776                         memcpy(__entry->ht_capa,
 777                                params->link_sta_params.ht_capa,
 778                                sizeof(struct ieee80211_ht_cap));
 779                 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap));
 780                 if (params->link_sta_params.vht_capa)
 781                         memcpy(__entry->vht_capa,
 782                                params->link_sta_params.vht_capa,
 783                                sizeof(struct ieee80211_vht_cap));
 784                 memset(__entry->vlan, 0, sizeof(__entry->vlan));
 785                 if (params->vlan)
 786                         memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ);
 787                 if (params->link_sta_params.supported_rates &&
 788                     params->link_sta_params.supported_rates_len)
 789                         memcpy(__get_dynamic_array(supported_rates),
 790                                params->link_sta_params.supported_rates,
 791                                params->link_sta_params.supported_rates_len);
 792                 if (params->ext_capab && params->ext_capab_len)
 793                         memcpy(__get_dynamic_array(ext_capab),
 794                                params->ext_capab,
 795                                params->ext_capab_len);
 796                 if (params->supported_channels &&
 797                     params->supported_channels_len)
 798                         memcpy(__get_dynamic_array(supported_channels),
 799                                params->supported_channels,
 800                                params->supported_channels_len);
 801                 if (params->supported_oper_classes &&
 802                     params->supported_oper_classes_len)
 803                         memcpy(__get_dynamic_array(supported_oper_classes),
 804                                params->supported_oper_classes,
 805                                params->supported_oper_classes_len);
 806                 __entry->max_sp = params->max_sp;
 807                 __entry->capability = params->capability;
 808                 __entry->opmode_notif = params->link_sta_params.opmode_notif;
 809                 __entry->opmode_notif_used =
 810                         params->link_sta_params.opmode_notif_used;
 811         ),
 812         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
 813                   ", station flags mask: %u, station flags set: %u, "
 814                   "station modify mask: %u, listen interval: %d, aid: %u, "
 815                   "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s",
 816                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
 817                   __entry->sta_flags_mask, __entry->sta_flags_set,
 818                   __entry->sta_modify_mask, __entry->listen_interval,
 819                   __entry->aid, __entry->plink_action, __entry->plink_state,
 820                   __entry->uapsd_queues, __entry->vlan)
 821 );
 822
 823 DEFINE_EVENT(station_add_change, rdev_add_station,
 824         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
 825                  struct station_parameters *params),
 826         TP_ARGS(wiphy, netdev, mac, params)
 827 );
 828
 829 DEFINE_EVENT(station_add_change, rdev_change_station,
 830         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
 831                  struct station_parameters *params),
 832         TP_ARGS(wiphy, netdev, mac, params)
 833 );
 834
 835 DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt,
 836         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 837         TP_ARGS(wiphy, netdev, mac),
 838         TP_STRUCT__entry(
 839                 WIPHY_ENTRY
 840                 NETDEV_ENTRY
 841                 MAC_ENTRY(sta_mac)
 842         ),
 843         TP_fast_assign(
 844                 WIPHY_ASSIGN;
 845                 NETDEV_ASSIGN;
 846                 MAC_ASSIGN(sta_mac, mac);
 847         ),
 848         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: %pM",
 849                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac)
 850 );
 851
 852 DECLARE_EVENT_CLASS(station_del,
 853         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 854                  struct station_del_parameters *params),
 855         TP_ARGS(wiphy, netdev, params),
 856         TP_STRUCT__entry(
 857                 WIPHY_ENTRY
 858                 NETDEV_ENTRY
 859                 MAC_ENTRY(sta_mac)
 860                 __field(u8, subtype)
 861                 __field(u16, reason_code)
 862         ),
 863         TP_fast_assign(
 864                 WIPHY_ASSIGN;
 865                 NETDEV_ASSIGN;
 866                 MAC_ASSIGN(sta_mac, params->mac);
 867                 __entry->subtype = params->subtype;
 868                 __entry->reason_code = params->reason_code;
 869         ),
 870         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
 871                   ", subtype: %u, reason_code: %u",
 872                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
 873                   __entry->subtype, __entry->reason_code)
 874 );
 875
 876 DEFINE_EVENT(station_del, rdev_del_station,
 877         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 878                  struct station_del_parameters *params),
 879         TP_ARGS(wiphy, netdev, params)
 880 );
 881
 882 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station,
 883         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 884         TP_ARGS(wiphy, netdev, mac)
 885 );
 886
 887 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath,
 888         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 889         TP_ARGS(wiphy, netdev, mac)
 890 );
 891
 892 TRACE_EVENT(rdev_dump_station,
 893         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
 894                  u8 *mac),
 895         TP_ARGS(wiphy, netdev, _idx, mac),
 896         TP_STRUCT__entry(
 897                 WIPHY_ENTRY
 898                 NETDEV_ENTRY
 899                 MAC_ENTRY(sta_mac)
 900                 __field(int, idx)
 901         ),
 902         TP_fast_assign(
 903                 WIPHY_ASSIGN;
 904                 NETDEV_ASSIGN;
 905                 MAC_ASSIGN(sta_mac, mac);
 906                 __entry->idx = _idx;
 907         ),
 908         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM, idx: %d",
 909                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
 910                   __entry->idx)
 911 );
 912
 913 TRACE_EVENT(rdev_return_int_station_info,
 914         TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo),
 915         TP_ARGS(wiphy, ret, sinfo),
 916         TP_STRUCT__entry(
 917                 WIPHY_ENTRY
 918                 __field(int, ret)
 919                 SINFO_ENTRY
 920         ),
 921         TP_fast_assign(
 922                 WIPHY_ASSIGN;
 923                 __entry->ret = ret;
 924                 SINFO_ASSIGN;
 925         ),
 926         TP_printk(WIPHY_PR_FMT ", returned %d" ,
 927                   WIPHY_PR_ARG, __entry->ret)
 928 );
 929
 930 DECLARE_EVENT_CLASS(mpath_evt,
 931         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 932                  u8 *next_hop),
 933         TP_ARGS(wiphy, netdev, dst, next_hop),
 934         TP_STRUCT__entry(
 935                 WIPHY_ENTRY
 936                 NETDEV_ENTRY
 937                 MAC_ENTRY(dst)
 938                 MAC_ENTRY(next_hop)
 939         ),
 940         TP_fast_assign(
 941                 WIPHY_ASSIGN;
 942                 NETDEV_ASSIGN;
 943                 MAC_ASSIGN(dst, dst);
 944                 MAC_ASSIGN(next_hop, next_hop);
 945         ),
 946         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM, next hop: %pM",
 947                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dst,
 948                   __entry->next_hop)
 949 );
 950
 951 DEFINE_EVENT(mpath_evt, rdev_add_mpath,
 952         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 953                  u8 *next_hop),
 954         TP_ARGS(wiphy, netdev, dst, next_hop)
 955 );
 956
 957 DEFINE_EVENT(mpath_evt, rdev_change_mpath,
 958         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 959                  u8 *next_hop),
 960         TP_ARGS(wiphy, netdev, dst, next_hop)
 961 );
 962
 963 DEFINE_EVENT(mpath_evt, rdev_get_mpath,
 964         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
 965                  u8 *next_hop),
 966         TP_ARGS(wiphy, netdev, dst, next_hop)
 967 );
 968
 969 TRACE_EVENT(rdev_dump_mpath,
 970         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
 971                  u8 *dst, u8 *next_hop),
 972         TP_ARGS(wiphy, netdev, _idx, dst, next_hop),
 973         TP_STRUCT__entry(
 974                 WIPHY_ENTRY
 975                 NETDEV_ENTRY
 976                 MAC_ENTRY(dst)
 977                 MAC_ENTRY(next_hop)
 978                 __field(int, idx)
 979         ),
 980         TP_fast_assign(
 981                 WIPHY_ASSIGN;
 982                 NETDEV_ASSIGN;
 983                 MAC_ASSIGN(dst, dst);
 984                 MAC_ASSIGN(next_hop, next_hop);
 985                 __entry->idx = _idx;
 986         ),
 987         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, next hop: %pM",
 988                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,
 989                   __entry->next_hop)
 990 );
 991
 992 TRACE_EVENT(rdev_get_mpp,
 993         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
 994                  u8 *dst, u8 *mpp),
 995         TP_ARGS(wiphy, netdev, dst, mpp),
 996         TP_STRUCT__entry(
 997                 WIPHY_ENTRY
 998                 NETDEV_ENTRY
 999                 MAC_ENTRY(dst)
1000                 MAC_ENTRY(mpp)
1001         ),
1002         TP_fast_assign(
1003                 WIPHY_ASSIGN;
1004                 NETDEV_ASSIGN;
1005                 MAC_ASSIGN(dst, dst);
1006                 MAC_ASSIGN(mpp, mpp);
1007         ),
1008         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM"
1009                   ", mpp: %pM", WIPHY_PR_ARG, NETDEV_PR_ARG,
1010                   __entry->dst, __entry->mpp)
1011 );
1012
1013 TRACE_EVENT(rdev_dump_mpp,
1014         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
1015                  u8 *dst, u8 *mpp),
1016         TP_ARGS(wiphy, netdev, _idx, mpp, dst),
1017         TP_STRUCT__entry(
1018                 WIPHY_ENTRY
1019                 NETDEV_ENTRY
1020                 MAC_ENTRY(dst)
1021                 MAC_ENTRY(mpp)
1022                 __field(int, idx)
1023         ),
1024         TP_fast_assign(
1025                 WIPHY_ASSIGN;
1026                 NETDEV_ASSIGN;
1027                 MAC_ASSIGN(dst, dst);
1028                 MAC_ASSIGN(mpp, mpp);
1029                 __entry->idx = _idx;
1030         ),
1031         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, mpp: %pM",
1032                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,
1033                   __entry->mpp)
1034 );
1035
1036 TRACE_EVENT(rdev_return_int_mpath_info,
1037         TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo),
1038         TP_ARGS(wiphy, ret, pinfo),
1039         TP_STRUCT__entry(
1040                 WIPHY_ENTRY
1041                 __field(int, ret)
1042                 __field(int, generation)
1043                 __field(u32, filled)
1044                 __field(u32, frame_qlen)
1045                 __field(u32, sn)
1046                 __field(u32, metric)
1047                 __field(u32, exptime)
1048                 __field(u32, discovery_timeout)
1049                 __field(u8, discovery_retries)
1050                 __field(u8, flags)
1051         ),
1052         TP_fast_assign(
1053                 WIPHY_ASSIGN;
1054                 __entry->ret = ret;
1055                 __entry->generation = pinfo->generation;
1056                 __entry->filled = pinfo->filled;
1057                 __entry->frame_qlen = pinfo->frame_qlen;
1058                 __entry->sn = pinfo->sn;
1059                 __entry->metric = pinfo->metric;
1060                 __entry->exptime = pinfo->exptime;
1061                 __entry->discovery_timeout = pinfo->discovery_timeout;
1062                 __entry->discovery_retries = pinfo->discovery_retries;
1063                 __entry->flags = pinfo->flags;
1064         ),
1065         TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, "
1066                   "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u,"
1067                   " discovery timeout: %u, discovery retries: %u, flags: %u",
1068                   WIPHY_PR_ARG, __entry->ret, __entry->generation,
1069                   __entry->filled, __entry->frame_qlen, __entry->sn,
1070                   __entry->metric, __entry->exptime, __entry->discovery_timeout,
1071                   __entry->discovery_retries, __entry->flags)
1072 );
1073
1074 TRACE_EVENT(rdev_return_int_mesh_config,
1075         TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf),
1076         TP_ARGS(wiphy, ret, conf),
1077         TP_STRUCT__entry(
1078                 WIPHY_ENTRY
1079                 MESH_CFG_ENTRY
1080                 __field(int, ret)
1081         ),
1082         TP_fast_assign(
1083                 WIPHY_ASSIGN;
1084                 MESH_CFG_ASSIGN;
1085                 __entry->ret = ret;
1086         ),
1087         TP_printk(WIPHY_PR_FMT ", returned: %d",
1088                   WIPHY_PR_ARG, __entry->ret)
1089 );
1090
1091 TRACE_EVENT(rdev_update_mesh_config,
1092         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask,
1093                  const struct mesh_config *conf),
1094         TP_ARGS(wiphy, netdev, mask, conf),
1095         TP_STRUCT__entry(
1096                 WIPHY_ENTRY
1097                 NETDEV_ENTRY
1098                 MESH_CFG_ENTRY
1099                 __field(u32, mask)
1100         ),
1101         TP_fast_assign(
1102                 WIPHY_ASSIGN;
1103                 NETDEV_ASSIGN;
1104                 MESH_CFG_ASSIGN;
1105                 __entry->mask = mask;
1106         ),
1107         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u",
1108                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask)
1109 );
1110
1111 TRACE_EVENT(rdev_join_mesh,
1112         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1113                  const struct mesh_config *conf,
1114                  const struct mesh_setup *setup),
1115         TP_ARGS(wiphy, netdev, conf, setup),
1116         TP_STRUCT__entry(
1117                 WIPHY_ENTRY
1118                 NETDEV_ENTRY
1119                 MESH_CFG_ENTRY
1120         ),
1121         TP_fast_assign(
1122                 WIPHY_ASSIGN;
1123                 NETDEV_ASSIGN;
1124                 MESH_CFG_ASSIGN;
1125         ),
1126         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
1127                   WIPHY_PR_ARG, NETDEV_PR_ARG)
1128 );
1129
1130 TRACE_EVENT(rdev_change_bss,
1131         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1132                  struct bss_parameters *params),
1133         TP_ARGS(wiphy, netdev, params),
1134         TP_STRUCT__entry(
1135                 WIPHY_ENTRY
1136                 NETDEV_ENTRY
1137                 __field(int, use_cts_prot)
1138                 __field(int, use_short_preamble)
1139                 __field(int, use_short_slot_time)
1140                 __field(int, ap_isolate)
1141                 __field(int, ht_opmode)
1142         ),
1143         TP_fast_assign(
1144                 WIPHY_ASSIGN;
1145                 NETDEV_ASSIGN;
1146                 __entry->use_cts_prot = params->use_cts_prot;
1147                 __entry->use_short_preamble = params->use_short_preamble;
1148                 __entry->use_short_slot_time = params->use_short_slot_time;
1149                 __entry->ap_isolate = params->ap_isolate;
1150                 __entry->ht_opmode = params->ht_opmode;
1151         ),
1152         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, "
1153                   "use short preamble: %d, use short slot time: %d, "
1154                   "ap isolate: %d, ht opmode: %d",
1155                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot,
1156                   __entry->use_short_preamble, __entry->use_short_slot_time,
1157                   __entry->ap_isolate, __entry->ht_opmode)
1158 );
1159
1160 TRACE_EVENT(rdev_inform_bss,
1161         TP_PROTO(struct wiphy *wiphy, struct cfg80211_bss *bss),
1162         TP_ARGS(wiphy, bss),
1163         TP_STRUCT__entry(
1164                 WIPHY_ENTRY
1165                 MAC_ENTRY(bssid)
1166                 CHAN_ENTRY
1167         ),
1168         TP_fast_assign(
1169                 WIPHY_ASSIGN;
1170                 MAC_ASSIGN(bssid, bss->bssid);
1171                 CHAN_ASSIGN(bss->channel);
1172         ),
1173         TP_printk(WIPHY_PR_FMT ", %pM, " CHAN_PR_FMT,
1174                   WIPHY_PR_ARG, __entry->bssid, CHAN_PR_ARG)
1175 );
1176
1177 TRACE_EVENT(rdev_set_txq_params,
1178         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1179                  struct ieee80211_txq_params *params),
1180         TP_ARGS(wiphy, netdev, params),
1181         TP_STRUCT__entry(
1182                 WIPHY_ENTRY
1183                 NETDEV_ENTRY
1184                 __field(enum nl80211_ac, ac)
1185                 __field(u16, txop)
1186                 __field(u16, cwmin)
1187                 __field(u16, cwmax)
1188                 __field(u8, aifs)
1189         ),
1190         TP_fast_assign(
1191                 WIPHY_ASSIGN;
1192                 NETDEV_ASSIGN;
1193                 __entry->ac = params->ac;
1194                 __entry->txop = params->txop;
1195                 __entry->cwmin = params->cwmin;
1196                 __entry->cwmax = params->cwmax;
1197                 __entry->aifs = params->aifs;
1198         ),
1199         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u",
1200                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop,
1201                   __entry->cwmin, __entry->cwmax, __entry->aifs)
1202 );
1203
1204 TRACE_EVENT(rdev_libertas_set_mesh_channel,
1205         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1206                  struct ieee80211_channel *chan),
1207         TP_ARGS(wiphy, netdev, chan),
1208         TP_STRUCT__entry(
1209                 WIPHY_ENTRY
1210                 NETDEV_ENTRY
1211                 CHAN_ENTRY
1212         ),
1213         TP_fast_assign(
1214                 WIPHY_ASSIGN;
1215                 NETDEV_ASSIGN;
1216                 CHAN_ASSIGN(chan);
1217         ),
1218         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG,
1219                   NETDEV_PR_ARG, CHAN_PR_ARG)
1220 );
1221
1222 TRACE_EVENT(rdev_set_monitor_channel,
1223         TP_PROTO(struct wiphy *wiphy,
1224                  struct cfg80211_chan_def *chandef),
1225         TP_ARGS(wiphy, chandef),
1226         TP_STRUCT__entry(
1227                 WIPHY_ENTRY
1228                 CHAN_DEF_ENTRY
1229         ),
1230         TP_fast_assign(
1231                 WIPHY_ASSIGN;
1232                 CHAN_DEF_ASSIGN(chandef);
1233         ),
1234         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
1235                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
1236 );
1237
1238 TRACE_EVENT(rdev_auth,
1239         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1240                  struct cfg80211_auth_request *req),
1241         TP_ARGS(wiphy, netdev, req),
1242         TP_STRUCT__entry(
1243                 WIPHY_ENTRY
1244                 NETDEV_ENTRY
1245                 MAC_ENTRY(bssid)
1246                 __field(enum nl80211_auth_type, auth_type)
1247         ),
1248         TP_fast_assign(
1249                 WIPHY_ASSIGN;
1250                 NETDEV_ASSIGN;
1251                 if (req->bss)
1252                         MAC_ASSIGN(bssid, req->bss->bssid);
1253                 else
1254                         eth_zero_addr(__entry->bssid);
1255                 __entry->auth_type = req->auth_type;
1256         ),
1257         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: %pM",
1258                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type,
1259                   __entry->bssid)
1260 );
1261
1262 TRACE_EVENT(rdev_assoc,
1263         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1264                  struct cfg80211_assoc_request *req),
1265         TP_ARGS(wiphy, netdev, req),
1266         TP_STRUCT__entry(
1267                 WIPHY_ENTRY
1268                 NETDEV_ENTRY
1269                 MAC_ENTRY(bssid)
1270                 MAC_ENTRY(prev_bssid)
1271                 __field(bool, use_mfp)
1272                 __field(u32, flags)
1273                 __dynamic_array(u8, elements, req->ie_len)
1274                 __array(u8, ht_capa, sizeof(struct ieee80211_ht_cap))
1275                 __array(u8, ht_capa_mask, sizeof(struct ieee80211_ht_cap))
1276                 __array(u8, vht_capa, sizeof(struct ieee80211_vht_cap))
1277                 __array(u8, vht_capa_mask, sizeof(struct ieee80211_vht_cap))
1278                 __dynamic_array(u8, fils_kek, req->fils_kek_len)
1279                 __dynamic_array(u8, fils_nonces,
1280                                 req->fils_nonces ? 2 * FILS_NONCE_LEN : 0)
1281         ),
1282         TP_fast_assign(
1283                 WIPHY_ASSIGN;
1284                 NETDEV_ASSIGN;
1285                 if (req->bss)
1286                         MAC_ASSIGN(bssid, req->bss->bssid);
1287                 else
1288                         eth_zero_addr(__entry->bssid);
1289                 MAC_ASSIGN(prev_bssid, req->prev_bssid);
1290                 __entry->use_mfp = req->use_mfp;
1291                 __entry->flags = req->flags;
1292                 if (req->ie)
1293                         memcpy(__get_dynamic_array(elements),
1294                                req->ie, req->ie_len);
1295                 memcpy(__entry->ht_capa, &req->ht_capa, sizeof(req->ht_capa));
1296                 memcpy(__entry->ht_capa_mask, &req->ht_capa_mask,
1297                        sizeof(req->ht_capa_mask));
1298                 memcpy(__entry->vht_capa, &req->vht_capa, sizeof(req->vht_capa));
1299                 memcpy(__entry->vht_capa_mask, &req->vht_capa_mask,
1300                        sizeof(req->vht_capa_mask));
1301                 if (req->fils_kek)
1302                         memcpy(__get_dynamic_array(fils_kek),
1303                                req->fils_kek, req->fils_kek_len);
1304                 if (req->fils_nonces)
1305                         memcpy(__get_dynamic_array(fils_nonces),
1306                                req->fils_nonces, 2 * FILS_NONCE_LEN);
1307         ),
1308         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
1309                   ", previous bssid: %pM, use mfp: %s, flags: %u",
1310                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
1311                   __entry->prev_bssid, BOOL_TO_STR(__entry->use_mfp),
1312                   __entry->flags)
1313 );
1314
1315 TRACE_EVENT(rdev_deauth,
1316         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1317                  struct cfg80211_deauth_request *req),
1318         TP_ARGS(wiphy, netdev, req),
1319         TP_STRUCT__entry(
1320                 WIPHY_ENTRY
1321                 NETDEV_ENTRY
1322                 MAC_ENTRY(bssid)
1323                 __field(u16, reason_code)
1324                 __field(bool, local_state_change)
1325         ),
1326         TP_fast_assign(
1327                 WIPHY_ASSIGN;
1328                 NETDEV_ASSIGN;
1329                 MAC_ASSIGN(bssid, req->bssid);
1330                 __entry->reason_code = req->reason_code;
1331                 __entry->local_state_change = req->local_state_change;
1332         ),
1333         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, reason: %u, local_state_change:%d",
1334                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
1335                   __entry->reason_code, __entry->local_state_change)
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                  const struct cfg80211_rx_assoc_resp_data *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                 __dynamic_array(u8, mgmt, len)
3594                 __field(s32, signal)
3595                 __field(u64, ts_boottime)
3596                 __field(u64, parent_tsf)
3597                 MAC_ENTRY(parent_bssid)
3598         ),
3599         TP_fast_assign(
3600                 WIPHY_ASSIGN;
3601                 CHAN_ASSIGN(data->chan);
3602                 if (mgmt)
3603                         memcpy(__get_dynamic_array(mgmt), mgmt, len);
3604                 __entry->signal = data->signal;
3605                 __entry->ts_boottime = data->boottime_ns;
3606                 __entry->parent_tsf = data->parent_tsf;
3607                 MAC_ASSIGN(parent_bssid, data->parent_bssid);
3608         ),
3609         TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT
3610                   "signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: %pM",
3611                   WIPHY_PR_ARG, CHAN_PR_ARG,
3612                   __entry->signal, (unsigned long long)__entry->ts_boottime,
3613                   (unsigned long long)__entry->parent_tsf,
3614                   __entry->parent_bssid)
3615 );
3616
3617 DECLARE_EVENT_CLASS(cfg80211_bss_evt,
3618         TP_PROTO(struct cfg80211_bss *pub),
3619         TP_ARGS(pub),
3620         TP_STRUCT__entry(
3621                 MAC_ENTRY(bssid)
3622                 CHAN_ENTRY
3623         ),
3624         TP_fast_assign(
3625                 MAC_ASSIGN(bssid, pub->bssid);
3626                 CHAN_ASSIGN(pub->channel);
3627         ),
3628         TP_printk("%pM, " CHAN_PR_FMT, __entry->bssid, CHAN_PR_ARG)
3629 );
3630
3631 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss,
3632         TP_PROTO(struct cfg80211_bss *pub),
3633         TP_ARGS(pub)
3634 );
3635
3636 TRACE_EVENT(cfg80211_return_uint,
3637         TP_PROTO(unsigned int ret),
3638         TP_ARGS(ret),
3639         TP_STRUCT__entry(
3640                 __field(unsigned int, ret)
3641         ),
3642         TP_fast_assign(
3643                 __entry->ret = ret;
3644         ),
3645         TP_printk("ret: %d", __entry->ret)
3646 );
3647
3648 TRACE_EVENT(cfg80211_return_u32,
3649         TP_PROTO(u32 ret),
3650         TP_ARGS(ret),
3651         TP_STRUCT__entry(
3652                 __field(u32, ret)
3653         ),
3654         TP_fast_assign(
3655                 __entry->ret = ret;
3656         ),
3657         TP_printk("ret: %u", __entry->ret)
3658 );
3659
3660 TRACE_EVENT(cfg80211_report_wowlan_wakeup,
3661         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3662                  struct cfg80211_wowlan_wakeup *wakeup),
3663         TP_ARGS(wiphy, wdev, wakeup),
3664         TP_STRUCT__entry(
3665                 WIPHY_ENTRY
3666                 WDEV_ENTRY
3667                 __field(bool, non_wireless)
3668                 __field(bool, disconnect)
3669                 __field(bool, magic_pkt)
3670                 __field(bool, gtk_rekey_failure)
3671                 __field(bool, eap_identity_req)
3672                 __field(bool, four_way_handshake)
3673                 __field(bool, rfkill_release)
3674                 __field(s32, pattern_idx)
3675                 __field(u32, packet_len)
3676                 __dynamic_array(u8, packet,
3677                                 wakeup ? wakeup->packet_present_len : 0)
3678         ),
3679         TP_fast_assign(
3680                 WIPHY_ASSIGN;
3681                 WDEV_ASSIGN;
3682                 __entry->non_wireless = !wakeup;
3683                 __entry->disconnect = wakeup ? wakeup->disconnect : false;
3684                 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false;
3685                 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false;
3686                 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false;
3687                 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false;
3688                 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false;
3689                 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false;
3690                 __entry->packet_len = wakeup ? wakeup->packet_len : false;
3691                 if (wakeup && wakeup->packet && wakeup->packet_present_len)
3692                         memcpy(__get_dynamic_array(packet), wakeup->packet,
3693                                wakeup->packet_present_len);
3694         ),
3695         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
3696 );
3697
3698 TRACE_EVENT(cfg80211_ft_event,
3699         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3700                  struct cfg80211_ft_event_params *ft_event),
3701         TP_ARGS(wiphy, netdev, ft_event),
3702         TP_STRUCT__entry(
3703                 WIPHY_ENTRY
3704                 NETDEV_ENTRY
3705                 __dynamic_array(u8, ies, ft_event->ies_len)
3706                 MAC_ENTRY(target_ap)
3707                 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len)
3708         ),
3709         TP_fast_assign(
3710                 WIPHY_ASSIGN;
3711                 NETDEV_ASSIGN;
3712                 if (ft_event->ies)
3713                         memcpy(__get_dynamic_array(ies), ft_event->ies,
3714                                ft_event->ies_len);
3715                 MAC_ASSIGN(target_ap, ft_event->target_ap);
3716                 if (ft_event->ric_ies)
3717                         memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies,
3718                                ft_event->ric_ies_len);
3719         ),
3720         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: %pM",
3721                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->target_ap)
3722 );
3723
3724 TRACE_EVENT(cfg80211_stop_iface,
3725         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
3726         TP_ARGS(wiphy, wdev),
3727         TP_STRUCT__entry(
3728                 WIPHY_ENTRY
3729                 WDEV_ENTRY
3730         ),
3731         TP_fast_assign(
3732                 WIPHY_ASSIGN;
3733                 WDEV_ASSIGN;
3734         ),
3735         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
3736                   WIPHY_PR_ARG, WDEV_PR_ARG)
3737 );
3738
3739 TRACE_EVENT(cfg80211_pmsr_report,
3740         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3741                  u64 cookie, const u8 *addr),
3742         TP_ARGS(wiphy, wdev, cookie, addr),
3743         TP_STRUCT__entry(
3744                 WIPHY_ENTRY
3745                 WDEV_ENTRY
3746                 __field(u64, cookie)
3747                 MAC_ENTRY(addr)
3748         ),
3749         TP_fast_assign(
3750                 WIPHY_ASSIGN;
3751                 WDEV_ASSIGN;
3752                 __entry->cookie = cookie;
3753                 MAC_ASSIGN(addr, addr);
3754         ),
3755         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld, %pM",
3756                   WIPHY_PR_ARG, WDEV_PR_ARG,
3757                   (unsigned long long)__entry->cookie,
3758                   __entry->addr)
3759 );
3760
3761 TRACE_EVENT(cfg80211_pmsr_complete,
3762         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
3763         TP_ARGS(wiphy, wdev, cookie),
3764         TP_STRUCT__entry(
3765                 WIPHY_ENTRY
3766                 WDEV_ENTRY
3767                 __field(u64, cookie)
3768         ),
3769         TP_fast_assign(
3770                 WIPHY_ASSIGN;
3771                 WDEV_ASSIGN;
3772                 __entry->cookie = cookie;
3773         ),
3774         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld",
3775                   WIPHY_PR_ARG, WDEV_PR_ARG,
3776                   (unsigned long long)__entry->cookie)
3777 );
3778
3779 TRACE_EVENT(cfg80211_update_owe_info_event,
3780         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3781                  struct cfg80211_update_owe_info *owe_info),
3782         TP_ARGS(wiphy, netdev, owe_info),
3783         TP_STRUCT__entry(
3784                 WIPHY_ENTRY
3785                 NETDEV_ENTRY
3786                 MAC_ENTRY(peer)
3787                 __dynamic_array(u8, ie, owe_info->ie_len)
3788                 __field(int, assoc_link_id)
3789                 MAC_ENTRY(peer_mld_addr)
3790         ),
3791         TP_fast_assign(
3792                 WIPHY_ASSIGN;
3793                 NETDEV_ASSIGN;
3794                 MAC_ASSIGN(peer, owe_info->peer);
3795                 memcpy(__get_dynamic_array(ie), owe_info->ie,
3796                        owe_info->ie_len);
3797                 __entry->assoc_link_id = owe_info->assoc_link_id;
3798                 MAC_ASSIGN(peer_mld_addr, owe_info->peer_mld_addr);
3799         ),
3800         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM,"
3801                   " assoc_link_id: %d, peer_mld_addr: %pM",
3802                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer,
3803                   __entry->assoc_link_id, __entry->peer_mld_addr)
3804 );
3805
3806 TRACE_EVENT(cfg80211_bss_color_notify,
3807         TP_PROTO(struct net_device *netdev,
3808                  enum nl80211_commands cmd,
3809                  u8 count, u64 color_bitmap),
3810         TP_ARGS(netdev, cmd, count, color_bitmap),
3811         TP_STRUCT__entry(
3812                 NETDEV_ENTRY
3813                 __field(u32, cmd)
3814                 __field(u8, count)
3815                 __field(u64, color_bitmap)
3816         ),
3817         TP_fast_assign(
3818                 NETDEV_ASSIGN;
3819                 __entry->cmd = cmd;
3820                 __entry->count = count;
3821                 __entry->color_bitmap = color_bitmap;
3822         ),
3823         TP_printk(NETDEV_PR_FMT ", cmd: %x, count: %u, bitmap: %llx",
3824                   NETDEV_PR_ARG, __entry->cmd, __entry->count,
3825                   __entry->color_bitmap)
3826 );
3827
3828 TRACE_EVENT(cfg80211_assoc_comeback,
3829         TP_PROTO(struct wireless_dev *wdev, const u8 *ap_addr, u32 timeout),
3830         TP_ARGS(wdev, ap_addr, timeout),
3831         TP_STRUCT__entry(
3832                 WDEV_ENTRY
3833                 MAC_ENTRY(ap_addr)
3834                 __field(u32, timeout)
3835         ),
3836         TP_fast_assign(
3837                 WDEV_ASSIGN;
3838                 MAC_ASSIGN(ap_addr, ap_addr);
3839                 __entry->timeout = timeout;
3840         ),
3841         TP_printk(WDEV_PR_FMT ", %pM, timeout: %u TUs",
3842                   WDEV_PR_ARG, __entry->ap_addr, __entry->timeout)
3843 );
3844
3845 DECLARE_EVENT_CLASS(link_station_add_mod,
3846         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3847                  struct link_station_parameters *params),
3848         TP_ARGS(wiphy, netdev, params),
3849         TP_STRUCT__entry(
3850                 WIPHY_ENTRY
3851                 NETDEV_ENTRY
3852                 __array(u8, mld_mac, 6)
3853                 __array(u8, link_mac, 6)
3854                 __field(u32, link_id)
3855                 __dynamic_array(u8, supported_rates,
3856                                 params->supported_rates_len)
3857                 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
3858                 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap))
3859                 __field(u8, opmode_notif)
3860                 __field(bool, opmode_notif_used)
3861                 __dynamic_array(u8, he_capa, params->he_capa_len)
3862                 __array(u8, he_6ghz_capa, (int)sizeof(struct ieee80211_he_6ghz_capa))
3863                 __dynamic_array(u8, eht_capa, params->eht_capa_len)
3864         ),
3865         TP_fast_assign(
3866                 WIPHY_ASSIGN;
3867                 NETDEV_ASSIGN;
3868                 memset(__entry->mld_mac, 0, 6);
3869                 memset(__entry->link_mac, 0, 6);
3870                 if (params->mld_mac)
3871                         memcpy(__entry->mld_mac, params->mld_mac, 6);
3872                 if (params->link_mac)
3873                         memcpy(__entry->link_mac, params->link_mac, 6);
3874                 __entry->link_id = params->link_id;
3875                 if (params->supported_rates && params->supported_rates_len)
3876                         memcpy(__get_dynamic_array(supported_rates),
3877                                params->supported_rates,
3878                                params->supported_rates_len);
3879                 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
3880                 if (params->ht_capa)
3881                         memcpy(__entry->ht_capa, params->ht_capa,
3882                                sizeof(struct ieee80211_ht_cap));
3883                 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap));
3884                 if (params->vht_capa)
3885                         memcpy(__entry->vht_capa, params->vht_capa,
3886                                sizeof(struct ieee80211_vht_cap));
3887                 __entry->opmode_notif = params->opmode_notif;
3888                 __entry->opmode_notif_used = params->opmode_notif_used;
3889                 if (params->he_capa && params->he_capa_len)
3890                         memcpy(__get_dynamic_array(he_capa), params->he_capa,
3891                                params->he_capa_len);
3892                 memset(__entry->he_6ghz_capa, 0, sizeof(struct ieee80211_he_6ghz_capa));
3893                 if (params->he_6ghz_capa)
3894                         memcpy(__entry->he_6ghz_capa, params->he_6ghz_capa,
3895                                sizeof(struct ieee80211_he_6ghz_capa));
3896                 if (params->eht_capa && params->eht_capa_len)
3897                         memcpy(__get_dynamic_array(eht_capa), params->eht_capa,
3898                                params->eht_capa_len);
3899         ),
3900         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
3901                   ", link mac: %pM, link id: %u",
3902                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac,
3903                   __entry->link_mac, __entry->link_id)
3904 );
3905
3906 DEFINE_EVENT(link_station_add_mod, rdev_add_link_station,
3907         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3908                  struct link_station_parameters *params),
3909         TP_ARGS(wiphy, netdev, params)
3910 );
3911
3912 DEFINE_EVENT(link_station_add_mod, rdev_mod_link_station,
3913         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3914                  struct link_station_parameters *params),
3915         TP_ARGS(wiphy, netdev, params)
3916 );
3917
3918 TRACE_EVENT(rdev_del_link_station,
3919         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3920                  struct link_station_del_parameters *params),
3921         TP_ARGS(wiphy, netdev, params),
3922         TP_STRUCT__entry(
3923                 WIPHY_ENTRY
3924                 NETDEV_ENTRY
3925                 __array(u8, mld_mac, 6)
3926                 __field(u32, link_id)
3927         ),
3928         TP_fast_assign(
3929                 WIPHY_ASSIGN;
3930                 NETDEV_ASSIGN;
3931                 memset(__entry->mld_mac, 0, 6);
3932                 if (params->mld_mac)
3933                         memcpy(__entry->mld_mac, params->mld_mac, 6);
3934                 __entry->link_id = params->link_id;
3935         ),
3936         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
3937                   ", link id: %u",
3938                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac,
3939                   __entry->link_id)
3940 );
3941
3942 TRACE_EVENT(rdev_set_hw_timestamp,
3943         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3944                  struct cfg80211_set_hw_timestamp *hwts),
3945
3946         TP_ARGS(wiphy, netdev, hwts),
3947
3948         TP_STRUCT__entry(
3949                 WIPHY_ENTRY
3950                 NETDEV_ENTRY
3951                 MAC_ENTRY(macaddr)
3952                 __field(bool, enable)
3953         ),
3954
3955         TP_fast_assign(
3956                 WIPHY_ASSIGN;
3957                 NETDEV_ASSIGN;
3958                 MAC_ASSIGN(macaddr, hwts->macaddr);
3959                 __entry->enable = hwts->enable;
3960         ),
3961
3962         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac %pM, enable: %u",
3963                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr,
3964                   __entry->enable)
3965 );
3966
3967 TRACE_EVENT(cfg80211_links_removed,
3968         TP_PROTO(struct net_device *netdev, u16 link_mask),
3969         TP_ARGS(netdev, link_mask),
3970         TP_STRUCT__entry(
3971                 NETDEV_ENTRY
3972                 __field(u16, link_mask)
3973         ),
3974         TP_fast_assign(
3975                 NETDEV_ASSIGN;
3976                 __entry->link_mask = link_mask;
3977         ),
3978         TP_printk(NETDEV_PR_FMT ", link_mask:%u", NETDEV_PR_ARG,
3979                   __entry->link_mask)
3980 );
3981
3982 TRACE_EVENT(rdev_set_ttlm,
3983         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3984                  struct cfg80211_ttlm_params *params),
3985         TP_ARGS(wiphy, netdev, params),
3986         TP_STRUCT__entry(
3987                 WIPHY_ENTRY
3988                 NETDEV_ENTRY
3989                 __array(u8, dlink, sizeof(u16) * 8)
3990                 __array(u8, ulink, sizeof(u16) * 8)
3991         ),
3992         TP_fast_assign(
3993                 WIPHY_ASSIGN;
3994                 NETDEV_ASSIGN;
3995                 memcpy(__entry->dlink, params->dlink, sizeof(params->dlink));
3996                 memcpy(__entry->ulink, params->ulink, sizeof(params->ulink));
3997         ),
3998         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
3999                   WIPHY_PR_ARG, NETDEV_PR_ARG)
4000 );
4001
4002 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */
4003
4004 #undef TRACE_INCLUDE_PATH
4005 #define TRACE_INCLUDE_PATH .
4006 #undef TRACE_INCLUDE_FILE
4007 #define TRACE_INCLUDE_FILE trace
4008 #include <trace/define_trace.h>