Quelle  trace.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Portions of this file
 * Copyright(c) 2016-2017 Intel Deutschland GmbH
 * Copyright (C) 2018, 2020-2025 Intel Corporation
 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM cfg80211

#if !defined(__RDEV_OPS_TRACE) || defined(TRACE_HEADER_MULTI_READ)
#define __RDEV_OPS_TRACE

#include <linux/tracepoint.h>

#include <linux/rtnetlink.h>
#include <linux/etherdevice.h>
#include <net/cfg80211.h>
#include "core.h"

#define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN)
#define MAC_ASSIGN(entry_mac, given_mac) do {        \
 if (given_mac)           \
  memcpy(__entry->entry_mac, given_mac, ETH_ALEN);     \
 else            \
  eth_zero_addr(__entry->entry_mac);       \
 } while (0)

#define MAXNAME  32
#define WIPHY_ENTRY __array(char, wiphy_name, 32)
#define WIPHY_ASSIGN strscpy(__entry->wiphy_name, wiphy_name(wiphy), MAXNAME)
#define WIPHY_PR_FMT "%s"
#define WIPHY_PR_ARG __entry->wiphy_name

#define WDEV_ENTRY __field(u32, id)
#define WDEV_ASSIGN (__entry->id) = (!IS_ERR_OR_NULL(wdev) \
      ? wdev->identifier : 0)
#define WDEV_PR_FMT "wdev(%u)"
#define WDEV_PR_ARG (__entry->id)

#define NETDEV_ENTRY __array(char, name, IFNAMSIZ) \
   __field(int, ifindex)
#define NETDEV_ASSIGN            \
 do {             \
  memcpy(__entry->name, netdev->name, IFNAMSIZ); \
  (__entry->ifindex) = (netdev->ifindex);        \
 } while (0)
#define NETDEV_PR_FMT "netdev:%s(%d)"
#define NETDEV_PR_ARG __entry->name, __entry->ifindex

#define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout)     \
         __field(u16, dot11MeshConfirmTimeout)     \
         __field(u16, dot11MeshHoldingTimeout)     \
         __field(u16, dot11MeshMaxPeerLinks)     \
         __field(u8, dot11MeshMaxRetries)      \
         __field(u8, dot11MeshTTL)      \
         __field(u8, element_ttl)       \
         __field(bool, auto_open_plinks)      \
         __field(u32, dot11MeshNbrOffsetMaxNeighbor)    \
         __field(u8, dot11MeshHWMPmaxPREQretries)     \
         __field(u32, path_refresh_time)      \
         __field(u32, dot11MeshHWMPactivePathTimeout)    \
         __field(u16, min_discovery_timeout)     \
         __field(u16, dot11MeshHWMPpreqMinInterval)    \
         __field(u16, dot11MeshHWMPperrMinInterval)    \
         __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \
         __field(u8, dot11MeshHWMPRootMode)     \
         __field(u16, dot11MeshHWMPRannInterval)     \
         __field(bool, dot11MeshGateAnnouncementProtocol)    \
         __field(bool, dot11MeshForwarding)     \
         __field(s32, rssi_threshold)      \
         __field(u16, ht_opmode)       \
         __field(u32, dot11MeshHWMPactivePathToRootTimeout)  \
         __field(u16, dot11MeshHWMProotInterval)     \
         __field(u16, dot11MeshHWMPconfirmationInterval)    \
         __field(bool, dot11MeshNolearn)
#define MESH_CFG_ASSIGN             \
 do {              \
  __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \
  __entry->dot11MeshConfirmTimeout =         \
    conf->dot11MeshConfirmTimeout;        \
  __entry->dot11MeshHoldingTimeout =         \
    conf->dot11MeshHoldingTimeout;        \
  __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \
  __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries;     \
  __entry->dot11MeshTTL = conf->dot11MeshTTL;        \
  __entry->element_ttl = conf->element_ttl;        \
  __entry->auto_open_plinks = conf->auto_open_plinks;       \
  __entry->dot11MeshNbrOffsetMaxNeighbor =        \
    conf->dot11MeshNbrOffsetMaxNeighbor;       \
  __entry->dot11MeshHWMPmaxPREQretries =         \
    conf->dot11MeshHWMPmaxPREQretries;       \
  __entry->path_refresh_time = conf->path_refresh_time;       \
  __entry->dot11MeshHWMPactivePathTimeout =        \
    conf->dot11MeshHWMPactivePathTimeout;       \
  __entry->min_discovery_timeout = conf->min_discovery_timeout; \
  __entry->dot11MeshHWMPpreqMinInterval =         \
    conf->dot11MeshHWMPpreqMinInterval;       \
  __entry->dot11MeshHWMPperrMinInterval =         \
    conf->dot11MeshHWMPperrMinInterval;       \
  __entry->dot11MeshHWMPnetDiameterTraversalTime =       \
    conf->dot11MeshHWMPnetDiameterTraversalTime;  \
  __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \
  __entry->dot11MeshHWMPRannInterval =         \
    conf->dot11MeshHWMPRannInterval;       \
  __entry->dot11MeshGateAnnouncementProtocol =        \
    conf->dot11MeshGateAnnouncementProtocol;      \
  __entry->dot11MeshForwarding = conf->dot11MeshForwarding;     \
  __entry->rssi_threshold = conf->rssi_threshold;        \
  __entry->ht_opmode = conf->ht_opmode;         \
  __entry->dot11MeshHWMPactivePathToRootTimeout =        \
    conf->dot11MeshHWMPactivePathToRootTimeout;   \
  __entry->dot11MeshHWMProotInterval =         \
    conf->dot11MeshHWMProotInterval;       \
  __entry->dot11MeshHWMPconfirmationInterval =        \
    conf->dot11MeshHWMPconfirmationInterval;      \
  __entry->dot11MeshNolearn = conf->dot11MeshNolearn;       \
 } while (0)

#define CHAN_ENTRY __field(enum nl80211_band, band) \
     __field(u32, center_freq)  \
     __field(u16, freq_offset)
#define CHAN_ASSIGN(chan)       \
 do {         \
  if (chan) {       \
   __entry->band = chan->band;    \
   __entry->center_freq = chan->center_freq; \
   __entry->freq_offset = chan->freq_offset; \
  } else {       \
   __entry->band = 0;     \
   __entry->center_freq = 0;    \
   __entry->freq_offset = 0;    \
  }        \
 } while (0)
#define CHAN_PR_FMT "band: %d, freq: %u.%03u"
#define CHAN_PR_ARG __entry->band, __entry->center_freq, __entry->freq_offset

#define CHAN_DEF_ENTRY __field(enum nl80211_band, band)  \
         __field(u32, control_freq)   \
         __field(u32, freq_offset)   \
         __field(u32, width)    \
         __field(u32, center_freq1)   \
         __field(u32, freq1_offset)   \
         __field(u32, center_freq2)   \
         __field(u16, punctured)
#define CHAN_DEF_ASSIGN(chandef)     \
 do {        \
  if ((chandef) && (chandef)->chan) {   \
   __entry->band = (chandef)->chan->band;  \
   __entry->control_freq =    \
    (chandef)->chan->center_freq;  \
   __entry->freq_offset =    \
    (chandef)->chan->freq_offset;  \
   __entry->width = (chandef)->width;  \
   __entry->center_freq1 = (chandef)->center_freq1;\
   __entry->freq1_offset = (chandef)->freq1_offset;\
   __entry->center_freq2 = (chandef)->center_freq2;\
   __entry->punctured = (chandef)->punctured; \
  } else {      \
   __entry->band = 0;    \
   __entry->control_freq = 0;   \
   __entry->freq_offset = 0;   \
   __entry->width = 0;    \
   __entry->center_freq1 = 0;   \
   __entry->freq1_offset = 0;   \
   __entry->center_freq2 = 0;   \
   __entry->punctured = 0;    \
  }       \
 } while (0)
#define CHAN_DEF_PR_FMT       \
 "band: %d, control freq: %u.%03u, width: %d, cf1: %u.%03u, cf2: %u, punct: 0x%x"
#define CHAN_DEF_PR_ARG __entry->band, __entry->control_freq,  \
   __entry->freq_offset, __entry->width,  \
   __entry->center_freq1, __entry->freq1_offset, \
   __entry->center_freq2, __entry->punctured

#define FILS_AAD_ASSIGN(fa)      \
 do {        \
  if (fa) {      \
   ether_addr_copy(__entry->macaddr, fa->macaddr); \
   __entry->kek_len = fa->kek_len;   \
  } else {      \
   eth_zero_addr(__entry->macaddr);  \
   __entry->kek_len = 0;    \
  }       \
 } while (0)
#define FILS_AAD_PR_FMT       \
 "macaddr: %pM, kek_len: %d"

#define SINFO_ENTRY __field(int, generation)     \
      __field(u32, connected_time)    \
      __field(u32, inactive_time)     \
      __field(u32, rx_bytes)     \
      __field(u32, tx_bytes)     \
      __field(u32, rx_packets)     \
      __field(u32, tx_packets)     \
      __field(u32, tx_retries)     \
      __field(u32, tx_failed)     \
      __field(u32, rx_dropped_misc)   \
      __field(u32, beacon_loss_count) \
      __field(u16, llid)      \
      __field(u16, plid)      \
      __field(u8, plink_state)
#define SINFO_ASSIGN             \
 do {              \
  __entry->generation = sinfo->generation;        \
  __entry->connected_time = sinfo->connected_time;       \
  __entry->inactive_time = sinfo->inactive_time;        \
  __entry->rx_bytes = sinfo->rx_bytes;         \
  __entry->tx_bytes = sinfo->tx_bytes;         \
  __entry->rx_packets = sinfo->rx_packets;        \
  __entry->tx_packets = sinfo->tx_packets;        \
  __entry->tx_retries = sinfo->tx_retries;        \
  __entry->tx_failed = sinfo->tx_failed;         \
  __entry->rx_dropped_misc = sinfo->rx_dropped_misc;     \
  __entry->beacon_loss_count = sinfo->beacon_loss_count; \
  __entry->llid = sinfo->llid;          \
  __entry->plid = sinfo->plid;          \
  __entry->plink_state = sinfo->plink_state;        \
 } while (0)

#define BOOL_TO_STR(bo) (bo) ? "true" : "false"

#define QOS_MAP_ENTRY __field(u8, num_des)   \
        __array(u8, dscp_exception,  \
         2 * IEEE80211_QOS_MAP_MAX_EX) \
        __array(u8, up, IEEE80211_QOS_MAP_LEN_MIN)
#define QOS_MAP_ASSIGN(qos_map)     \
 do {       \
  if ((qos_map)) {    \
   __entry->num_des = (qos_map)->num_des; \
   memcpy(__entry->dscp_exception,  \
          &(qos_map)->dscp_exception, \
          2 * IEEE80211_QOS_MAP_MAX_EX); \
   memcpy(__entry->up, &(qos_map)->up, \
          IEEE80211_QOS_MAP_LEN_MIN); \
  } else {     \
   __entry->num_des = 0;   \
   memset(__entry->dscp_exception, 0, \
          2 * IEEE80211_QOS_MAP_MAX_EX); \
   memset(__entry->up, 0,   \
          IEEE80211_QOS_MAP_LEN_MIN); \
  }      \
 } while (0)

/*************************************************************
 * wiphy work traces      *
 *************************************************************/

DECLARE_EVENT_CLASS(wiphy_work_event,
 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
 TP_ARGS(wiphy, work),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(void *, instance)
  __field(void *, func)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->instance = work;
  __entry->func = work ? work->func : NULL;
 ),
 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS",
    WIPHY_PR_ARG, __entry->instance, __entry->func)
);

DEFINE_EVENT(wiphy_work_event, wiphy_work_queue,
 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
 TP_ARGS(wiphy, work)
);

DEFINE_EVENT(wiphy_work_event, wiphy_work_run,
 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
 TP_ARGS(wiphy, work)
);

DEFINE_EVENT(wiphy_work_event, wiphy_work_cancel,
 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
 TP_ARGS(wiphy, work)
);

DEFINE_EVENT(wiphy_work_event, wiphy_work_flush,
 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
 TP_ARGS(wiphy, work)
);

TRACE_EVENT(wiphy_delayed_work_queue,
 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work,
   unsigned long delay),
 TP_ARGS(wiphy, work, delay),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(void *, instance)
  __field(void *, func)
  __field(unsigned long, delay)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->instance = work;
  __entry->func = work->func;
  __entry->delay = delay;
 ),
 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS delay=%ld",
    WIPHY_PR_ARG, __entry->instance, __entry->func,
    __entry->delay)
);

TRACE_EVENT(wiphy_hrtimer_work_queue,
 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work,
   ktime_t delay),
 TP_ARGS(wiphy, work, delay),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(void *, instance)
  __field(void *, func)
  __field(ktime_t, delay)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->instance = work;
  __entry->func = work->func;
  __entry->delay = delay;
 ),
 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS delay=%llu",
    WIPHY_PR_ARG, __entry->instance, __entry->func,
    __entry->delay)
);

TRACE_EVENT(wiphy_work_worker_start,
 TP_PROTO(struct wiphy *wiphy),
 TP_ARGS(wiphy),
 TP_STRUCT__entry(
  WIPHY_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
);

/*************************************************************
 * rdev->ops traces      *
 *************************************************************/

TRACE_EVENT(rdev_suspend,
 TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow),
 TP_ARGS(wiphy, wow),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(bool, any)
  __field(bool, disconnect)
  __field(bool, magic_pkt)
  __field(bool, gtk_rekey_failure)
  __field(bool, eap_identity_req)
  __field(bool, four_way_handshake)
  __field(bool, rfkill_release)
  __field(bool, valid_wow)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  if (wow) {
   __entry->any = wow->any;
   __entry->disconnect = wow->disconnect;
   __entry->magic_pkt = wow->magic_pkt;
   __entry->gtk_rekey_failure = wow->gtk_rekey_failure;
   __entry->eap_identity_req = wow->eap_identity_req;
   __entry->four_way_handshake = wow->four_way_handshake;
   __entry->rfkill_release = wow->rfkill_release;
   __entry->valid_wow = true;
  } else {
   __entry->valid_wow = false;
  }
 ),
 TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, "
    "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, "
    "four way handshake: %d, rfkill release: %d.",
    WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)",
    __entry->any, __entry->disconnect, __entry->magic_pkt,
    __entry->gtk_rekey_failure, __entry->eap_identity_req,
    __entry->four_way_handshake, __entry->rfkill_release)
);

TRACE_EVENT(rdev_return_int,
 TP_PROTO(struct wiphy *wiphy, int ret),
 TP_ARGS(wiphy, ret),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, ret)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->ret = ret;
 ),
 TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret)
);

TRACE_EVENT(rdev_scan,
 TP_PROTO(struct wiphy *wiphy,
   struct cfg80211_scan_request_int *request),
 TP_ARGS(wiphy, request),
 TP_STRUCT__entry(
  WIPHY_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
);

DECLARE_EVENT_CLASS(wiphy_only_evt,
 TP_PROTO(struct wiphy *wiphy),
 TP_ARGS(wiphy),
 TP_STRUCT__entry(
  WIPHY_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
);

DEFINE_EVENT(wiphy_only_evt, rdev_resume,
 TP_PROTO(struct wiphy *wiphy),
 TP_ARGS(wiphy)
);

DEFINE_EVENT(wiphy_only_evt, rdev_return_void,
 TP_PROTO(struct wiphy *wiphy),
 TP_ARGS(wiphy)
);

TRACE_EVENT(rdev_get_antenna,
 TP_PROTO(struct wiphy *wiphy, int radio_idx),
 TP_ARGS(wiphy, radio_idx),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, radio_idx)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->radio_idx = radio_idx;
 ),
 TP_printk(WIPHY_PR_FMT ", radio_idx: %d",
    WIPHY_PR_ARG, __entry->radio_idx)
);

DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll,
 TP_PROTO(struct wiphy *wiphy),
 TP_ARGS(wiphy)
);

DECLARE_EVENT_CLASS(wiphy_enabled_evt,
 TP_PROTO(struct wiphy *wiphy, bool enabled),
 TP_ARGS(wiphy, enabled),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(bool, enabled)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->enabled = enabled;
 ),
 TP_printk(WIPHY_PR_FMT ", %senabled ",
    WIPHY_PR_ARG, __entry->enabled ? "" : "not ")
);

DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup,
 TP_PROTO(struct wiphy *wiphy, bool enabled),
 TP_ARGS(wiphy, enabled)
);

TRACE_EVENT(rdev_add_virtual_intf,
 TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type),
 TP_ARGS(wiphy, name, type),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __string(vir_intf_name, name ? name : "")
  __field(enum nl80211_iftype, type)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __assign_str(vir_intf_name);
  __entry->type = type;
 ),
 TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d",
    WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type)
);

DECLARE_EVENT_CLASS(wiphy_wdev_evt,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
 TP_ARGS(wiphy, wdev),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
);

DECLARE_EVENT_CLASS(wiphy_wdev_cookie_evt,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
 TP_ARGS(wiphy, wdev, cookie),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  __field(u64, cookie)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  __entry->cookie = cookie;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %lld",
    WIPHY_PR_ARG, WDEV_PR_ARG,
    (unsigned long long)__entry->cookie)
);

DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
 TP_ARGS(wiphy, wdev)
);

DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
 TP_ARGS(wiphy, wdev)
);

TRACE_EVENT(rdev_change_virtual_intf,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   enum nl80211_iftype type),
 TP_ARGS(wiphy, netdev, type),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(enum nl80211_iftype, type)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->type = type;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", type: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type)
);

DECLARE_EVENT_CLASS(key_handle,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
   u8 key_index, bool pairwise, const u8 *mac_addr),
 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(mac_addr)
  __field(int, link_id)
  __field(u8, key_index)
  __field(bool, pairwise)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(mac_addr, mac_addr);
  __entry->link_id = link_id;
  __entry->key_index = key_index;
  __entry->pairwise = pairwise;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
    "key_index: %u, pairwise: %s, mac addr: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
    __entry->key_index, BOOL_TO_STR(__entry->pairwise),
    __entry->mac_addr)
);

DEFINE_EVENT(key_handle, rdev_get_key,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
   u8 key_index, bool pairwise, const u8 *mac_addr),
 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr)
);

DEFINE_EVENT(key_handle, rdev_del_key,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
   u8 key_index, bool pairwise, const u8 *mac_addr),
 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr)
);

TRACE_EVENT(rdev_add_key,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
   u8 key_index, bool pairwise, const u8 *mac_addr, u8 mode),
 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr, mode),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(mac_addr)
  __field(int, link_id)
  __field(u8, key_index)
  __field(bool, pairwise)
  __field(u8, mode)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(mac_addr, mac_addr);
  __entry->link_id = link_id;
  __entry->key_index = key_index;
  __entry->pairwise = pairwise;
  __entry->mode = mode;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
    "key_index: %u, mode: %u, pairwise: %s, "
    "mac addr: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
    __entry->key_index, __entry->mode,
    BOOL_TO_STR(__entry->pairwise), __entry->mac_addr)
);

TRACE_EVENT(rdev_set_default_key,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
   u8 key_index, bool unicast, bool multicast),
 TP_ARGS(wiphy, netdev, link_id, key_index, unicast, multicast),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(int, link_id)
  __field(u8, key_index)
  __field(bool, unicast)
  __field(bool, multicast)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->link_id = link_id;
  __entry->key_index = key_index;
  __entry->unicast = unicast;
  __entry->multicast = multicast;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
    "key index: %u, unicast: %s, multicast: %s",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
    __entry->key_index, BOOL_TO_STR(__entry->unicast),
    BOOL_TO_STR(__entry->multicast))
);

TRACE_EVENT(rdev_set_default_mgmt_key,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
   u8 key_index),
 TP_ARGS(wiphy, netdev, link_id, key_index),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(int, link_id)
  __field(u8, key_index)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->link_id = link_id;
  __entry->key_index = key_index;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
    "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG,
    __entry->link_id, __entry->key_index)
);

TRACE_EVENT(rdev_set_default_beacon_key,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
   u8 key_index),
 TP_ARGS(wiphy, netdev, link_id, key_index),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(int, link_id)
  __field(u8, key_index)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->link_id = link_id;
  __entry->key_index = key_index;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
    "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG,
    __entry->link_id, __entry->key_index)
);

TRACE_EVENT(rdev_start_ap,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_ap_settings *settings),
 TP_ARGS(wiphy, netdev, settings),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  CHAN_DEF_ENTRY
  __field(int, beacon_interval)
  __field(int, dtim_period)
  __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
  __field(enum nl80211_hidden_ssid, hidden_ssid)
  __field(u32, wpa_ver)
  __field(bool, privacy)
  __field(enum nl80211_auth_type, auth_type)
  __field(int, inactivity_timeout)
  __field(unsigned int, link_id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  CHAN_DEF_ASSIGN(&settings->chandef);
  __entry->beacon_interval = settings->beacon_interval;
  __entry->dtim_period = settings->dtim_period;
  __entry->hidden_ssid = settings->hidden_ssid;
  __entry->wpa_ver = settings->crypto.wpa_versions;
  __entry->privacy = settings->privacy;
  __entry->auth_type = settings->auth_type;
  __entry->inactivity_timeout = settings->inactivity_timeout;
  memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
  memcpy(__entry->ssid, settings->ssid, settings->ssid_len);
  __entry->link_id = settings->beacon.link_id;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", AP settings - ssid: %s, "
    CHAN_DEF_PR_FMT ", beacon interval: %d, dtim period: %d, "
    "hidden ssid: %d, wpa versions: %u, privacy: %s, "
    "auth type: %d, inactivity timeout: %d, link_id: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_DEF_PR_ARG,
    __entry->beacon_interval, __entry->dtim_period,
    __entry->hidden_ssid, __entry->wpa_ver,
    BOOL_TO_STR(__entry->privacy), __entry->auth_type,
    __entry->inactivity_timeout, __entry->link_id)
);

TRACE_EVENT(rdev_change_beacon,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_ap_update *info),
 TP_ARGS(wiphy, netdev, info),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(int, link_id)
  __dynamic_array(u8, head, info->beacon.head_len)
  __dynamic_array(u8, tail, info->beacon.tail_len)
  __dynamic_array(u8, beacon_ies, info->beacon.beacon_ies_len)
  __dynamic_array(u8, proberesp_ies, info->beacon.proberesp_ies_len)
  __dynamic_array(u8, assocresp_ies, info->beacon.assocresp_ies_len)
  __dynamic_array(u8, probe_resp, info->beacon.probe_resp_len)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->link_id = info->beacon.link_id;
  if (info->beacon.head)
   memcpy(__get_dynamic_array(head),
          info->beacon.head,
          info->beacon.head_len);
  if (info->beacon.tail)
   memcpy(__get_dynamic_array(tail),
          info->beacon.tail,
          info->beacon.tail_len);
  if (info->beacon.beacon_ies)
   memcpy(__get_dynamic_array(beacon_ies),
          info->beacon.beacon_ies,
          info->beacon.beacon_ies_len);
  if (info->beacon.proberesp_ies)
   memcpy(__get_dynamic_array(proberesp_ies),
          info->beacon.proberesp_ies,
          info->beacon.proberesp_ies_len);
  if (info->beacon.assocresp_ies)
   memcpy(__get_dynamic_array(assocresp_ies),
          info->beacon.assocresp_ies,
          info->beacon.assocresp_ies_len);
  if (info->beacon.probe_resp)
   memcpy(__get_dynamic_array(probe_resp),
          info->beacon.probe_resp,
          info->beacon.probe_resp_len);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id:%d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
);

TRACE_EVENT(rdev_stop_ap,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   unsigned int link_id),
 TP_ARGS(wiphy, netdev, link_id),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(unsigned int, link_id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->link_id = link_id;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
);

DECLARE_EVENT_CLASS(wiphy_netdev_evt,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 TP_ARGS(wiphy, netdev),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
);

DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 TP_ARGS(wiphy, netdev)
);

DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 TP_ARGS(wiphy, netdev)
);

DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 TP_ARGS(wiphy, netdev)
);

DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 TP_ARGS(wiphy, netdev)
);

DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 TP_ARGS(wiphy, netdev)
);

DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
 TP_ARGS(wiphy, netdev)
);

TRACE_EVENT(rdev_end_cac,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   unsigned int link_id),
 TP_ARGS(wiphy, netdev, link_id),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(unsigned int, link_id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->link_id = link_id;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
);

DECLARE_EVENT_CLASS(station_add_change,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
   struct station_parameters *params),
 TP_ARGS(wiphy, netdev, mac, params),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(sta_mac)
  __field(u32, sta_flags_mask)
  __field(u32, sta_flags_set)
  __field(u32, sta_modify_mask)
  __field(int, listen_interval)
  __field(u16, capability)
  __field(u16, aid)
  __field(u8, plink_action)
  __field(u8, plink_state)
  __field(u8, uapsd_queues)
  __field(u8, max_sp)
  __field(u8, opmode_notif)
  __field(bool, opmode_notif_used)
  __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
  __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap))
  __array(char, vlan, IFNAMSIZ)
  __dynamic_array(u8, supported_rates,
    params->link_sta_params.supported_rates_len)
  __dynamic_array(u8, ext_capab, params->ext_capab_len)
  __dynamic_array(u8, supported_channels,
    params->supported_channels_len)
  __dynamic_array(u8, supported_oper_classes,
    params->supported_oper_classes_len)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(sta_mac, mac);
  __entry->sta_flags_mask = params->sta_flags_mask;
  __entry->sta_flags_set = params->sta_flags_set;
  __entry->sta_modify_mask = params->sta_modify_mask;
  __entry->listen_interval = params->listen_interval;
  __entry->aid = params->aid;
  __entry->plink_action = params->plink_action;
  __entry->plink_state = params->plink_state;
  __entry->uapsd_queues = params->uapsd_queues;
  memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
  if (params->link_sta_params.ht_capa)
   memcpy(__entry->ht_capa,
          params->link_sta_params.ht_capa,
          sizeof(struct ieee80211_ht_cap));
  memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap));
  if (params->link_sta_params.vht_capa)
   memcpy(__entry->vht_capa,
          params->link_sta_params.vht_capa,
          sizeof(struct ieee80211_vht_cap));
  memset(__entry->vlan, 0, sizeof(__entry->vlan));
  if (params->vlan)
   memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ);
  if (params->link_sta_params.supported_rates &&
      params->link_sta_params.supported_rates_len)
   memcpy(__get_dynamic_array(supported_rates),
          params->link_sta_params.supported_rates,
          params->link_sta_params.supported_rates_len);
  if (params->ext_capab && params->ext_capab_len)
   memcpy(__get_dynamic_array(ext_capab),
          params->ext_capab,
          params->ext_capab_len);
  if (params->supported_channels &&
      params->supported_channels_len)
   memcpy(__get_dynamic_array(supported_channels),
          params->supported_channels,
          params->supported_channels_len);
  if (params->supported_oper_classes &&
      params->supported_oper_classes_len)
   memcpy(__get_dynamic_array(supported_oper_classes),
          params->supported_oper_classes,
          params->supported_oper_classes_len);
  __entry->max_sp = params->max_sp;
  __entry->capability = params->capability;
  __entry->opmode_notif = params->link_sta_params.opmode_notif;
  __entry->opmode_notif_used =
   params->link_sta_params.opmode_notif_used;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
    ", station flags mask: 0x%x, station flags set: 0x%x, "
    "station modify mask: 0x%x, listen interval: %d, aid: %u, "
    "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
    __entry->sta_flags_mask, __entry->sta_flags_set,
    __entry->sta_modify_mask, __entry->listen_interval,
    __entry->aid, __entry->plink_action, __entry->plink_state,
    __entry->uapsd_queues, __entry->vlan)
);

DEFINE_EVENT(station_add_change, rdev_add_station,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
   struct station_parameters *params),
 TP_ARGS(wiphy, netdev, mac, params)
);

DEFINE_EVENT(station_add_change, rdev_change_station,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
   struct station_parameters *params),
 TP_ARGS(wiphy, netdev, mac, params)
);

DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 TP_ARGS(wiphy, netdev, mac),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(sta_mac)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(sta_mac, mac);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac)
);

DECLARE_EVENT_CLASS(station_del,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct station_del_parameters *params),
 TP_ARGS(wiphy, netdev, params),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(sta_mac)
  __field(u8, subtype)
  __field(u16, reason_code)
  __field(int, link_id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(sta_mac, params->mac);
  __entry->subtype = params->subtype;
  __entry->reason_code = params->reason_code;
  __entry->link_id = params->link_id;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
    ", subtype: %u, reason_code: %u, link_id: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
    __entry->subtype, __entry->reason_code,
    __entry->link_id)
);

DEFINE_EVENT(station_del, rdev_del_station,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct station_del_parameters *params),
 TP_ARGS(wiphy, netdev, params)
);

DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 TP_ARGS(wiphy, netdev, mac)
);

DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
 TP_ARGS(wiphy, netdev, mac)
);

TRACE_EVENT(rdev_dump_station,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
   u8 *mac),
 TP_ARGS(wiphy, netdev, _idx, mac),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(sta_mac)
  __field(int, idx)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(sta_mac, mac);
  __entry->idx = _idx;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM, idx: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
    __entry->idx)
);

TRACE_EVENT(rdev_return_int_station_info,
 TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo),
 TP_ARGS(wiphy, ret, sinfo),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, ret)
  SINFO_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->ret = ret;
  SINFO_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT ", returned %d" ,
    WIPHY_PR_ARG, __entry->ret)
);

DECLARE_EVENT_CLASS(mpath_evt,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
   u8 *next_hop),
 TP_ARGS(wiphy, netdev, dst, next_hop),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(dst)
  MAC_ENTRY(next_hop)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(dst, dst);
  MAC_ASSIGN(next_hop, next_hop);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM, next hop: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dst,
    __entry->next_hop)
);

DEFINE_EVENT(mpath_evt, rdev_add_mpath,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
   u8 *next_hop),
 TP_ARGS(wiphy, netdev, dst, next_hop)
);

DEFINE_EVENT(mpath_evt, rdev_change_mpath,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
   u8 *next_hop),
 TP_ARGS(wiphy, netdev, dst, next_hop)
);

DEFINE_EVENT(mpath_evt, rdev_get_mpath,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
   u8 *next_hop),
 TP_ARGS(wiphy, netdev, dst, next_hop)
);

TRACE_EVENT(rdev_dump_mpath,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
   u8 *dst, u8 *next_hop),
 TP_ARGS(wiphy, netdev, _idx, dst, next_hop),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(dst)
  MAC_ENTRY(next_hop)
  __field(int, idx)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(dst, dst);
  MAC_ASSIGN(next_hop, next_hop);
  __entry->idx = _idx;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, next hop: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,
    __entry->next_hop)
);

TRACE_EVENT(rdev_get_mpp,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   u8 *dst, u8 *mpp),
 TP_ARGS(wiphy, netdev, dst, mpp),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(dst)
  MAC_ENTRY(mpp)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(dst, dst);
  MAC_ASSIGN(mpp, mpp);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM"
    ", mpp: %pM", WIPHY_PR_ARG, NETDEV_PR_ARG,
    __entry->dst, __entry->mpp)
);

TRACE_EVENT(rdev_dump_mpp,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
   u8 *dst, u8 *mpp),
 TP_ARGS(wiphy, netdev, _idx, dst, mpp),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(dst)
  MAC_ENTRY(mpp)
  __field(int, idx)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(dst, dst);
  MAC_ASSIGN(mpp, mpp);
  __entry->idx = _idx;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, mpp: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,
    __entry->mpp)
);

TRACE_EVENT(rdev_return_int_mpath_info,
 TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo),
 TP_ARGS(wiphy, ret, pinfo),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, ret)
  __field(int, generation)
  __field(u32, filled)
  __field(u32, frame_qlen)
  __field(u32, sn)
  __field(u32, metric)
  __field(u32, exptime)
  __field(u32, discovery_timeout)
  __field(u8, discovery_retries)
  __field(u8, flags)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->ret = ret;
  __entry->generation = pinfo->generation;
  __entry->filled = pinfo->filled;
  __entry->frame_qlen = pinfo->frame_qlen;
  __entry->sn = pinfo->sn;
  __entry->metric = pinfo->metric;
  __entry->exptime = pinfo->exptime;
  __entry->discovery_timeout = pinfo->discovery_timeout;
  __entry->discovery_retries = pinfo->discovery_retries;
  __entry->flags = pinfo->flags;
 ),
 TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, "
    "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u,"
    " discovery timeout: %u, discovery retries: %u, flags: 0x%x",
    WIPHY_PR_ARG, __entry->ret, __entry->generation,
    __entry->filled, __entry->frame_qlen, __entry->sn,
    __entry->metric, __entry->exptime, __entry->discovery_timeout,
    __entry->discovery_retries, __entry->flags)
);

TRACE_EVENT(rdev_return_int_mesh_config,
 TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf),
 TP_ARGS(wiphy, ret, conf),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  MESH_CFG_ENTRY
  __field(int, ret)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  MESH_CFG_ASSIGN;
  __entry->ret = ret;
 ),
 TP_printk(WIPHY_PR_FMT ", returned: %d",
    WIPHY_PR_ARG, __entry->ret)
);

TRACE_EVENT(rdev_update_mesh_config,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask,
   const struct mesh_config *conf),
 TP_ARGS(wiphy, netdev, mask, conf),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MESH_CFG_ENTRY
  __field(u32, mask)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MESH_CFG_ASSIGN;
  __entry->mask = mask;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask)
);

TRACE_EVENT(rdev_join_mesh,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   const struct mesh_config *conf,
   const struct mesh_setup *setup),
 TP_ARGS(wiphy, netdev, conf, setup),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MESH_CFG_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MESH_CFG_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
    WIPHY_PR_ARG, NETDEV_PR_ARG)
);

TRACE_EVENT(rdev_change_bss,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct bss_parameters *params),
 TP_ARGS(wiphy, netdev, params),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(int, use_cts_prot)
  __field(int, use_short_preamble)
  __field(int, use_short_slot_time)
  __field(int, ap_isolate)
  __field(int, ht_opmode)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->use_cts_prot = params->use_cts_prot;
  __entry->use_short_preamble = params->use_short_preamble;
  __entry->use_short_slot_time = params->use_short_slot_time;
  __entry->ap_isolate = params->ap_isolate;
  __entry->ht_opmode = params->ht_opmode;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, "
    "use short preamble: %d, use short slot time: %d, "
    "ap isolate: %d, ht opmode: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot,
    __entry->use_short_preamble, __entry->use_short_slot_time,
    __entry->ap_isolate, __entry->ht_opmode)
);

TRACE_EVENT(rdev_inform_bss,
 TP_PROTO(struct wiphy *wiphy, struct cfg80211_bss *bss),
 TP_ARGS(wiphy, bss),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  MAC_ENTRY(bssid)
  CHAN_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  MAC_ASSIGN(bssid, bss->bssid);
  CHAN_ASSIGN(bss->channel);
 ),
 TP_printk(WIPHY_PR_FMT ", %pM, " CHAN_PR_FMT,
    WIPHY_PR_ARG, __entry->bssid, CHAN_PR_ARG)
);

TRACE_EVENT(rdev_set_txq_params,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct ieee80211_txq_params *params),
 TP_ARGS(wiphy, netdev, params),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(enum nl80211_ac, ac)
  __field(u16, txop)
  __field(u16, cwmin)
  __field(u16, cwmax)
  __field(u8, aifs)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->ac = params->ac;
  __entry->txop = params->txop;
  __entry->cwmin = params->cwmin;
  __entry->cwmax = params->cwmax;
  __entry->aifs = params->aifs;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop,
    __entry->cwmin, __entry->cwmax, __entry->aifs)
);

TRACE_EVENT(rdev_libertas_set_mesh_channel,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct ieee80211_channel *chan),
 TP_ARGS(wiphy, netdev, chan),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  CHAN_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  CHAN_ASSIGN(chan);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG,
    NETDEV_PR_ARG, CHAN_PR_ARG)
);

TRACE_EVENT(rdev_set_monitor_channel,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_chan_def *chandef),
 TP_ARGS(wiphy, netdev, chandef),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  CHAN_DEF_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  CHAN_DEF_ASSIGN(chandef);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
    WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
);

TRACE_EVENT(rdev_auth,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_auth_request *req),
 TP_ARGS(wiphy, netdev, req),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(bssid)
  __field(enum nl80211_auth_type, auth_type)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  if (req->bss)
   MAC_ASSIGN(bssid, req->bss->bssid);
  else
   eth_zero_addr(__entry->bssid);
  __entry->auth_type = req->auth_type;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type,
    __entry->bssid)
);

TRACE_EVENT(rdev_assoc,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_assoc_request *req),
 TP_ARGS(wiphy, netdev, req),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(bssid)
  MAC_ENTRY(prev_bssid)
  __field(bool, use_mfp)
  __field(u32, flags)
  __dynamic_array(u8, elements, req->ie_len)
  __array(u8, ht_capa, sizeof(struct ieee80211_ht_cap))
  __array(u8, ht_capa_mask, sizeof(struct ieee80211_ht_cap))
  __array(u8, vht_capa, sizeof(struct ieee80211_vht_cap))
  __array(u8, vht_capa_mask, sizeof(struct ieee80211_vht_cap))
  __dynamic_array(u8, fils_kek, req->fils_kek_len)
  __dynamic_array(u8, fils_nonces,
    req->fils_nonces ? 2 * FILS_NONCE_LEN : 0)
  __field(u16, ext_mld_capa_ops)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  if (req->bss)
   MAC_ASSIGN(bssid, req->bss->bssid);
  else
   eth_zero_addr(__entry->bssid);
  MAC_ASSIGN(prev_bssid, req->prev_bssid);
  __entry->use_mfp = req->use_mfp;
  __entry->flags = req->flags;
  if (req->ie)
   memcpy(__get_dynamic_array(elements),
          req->ie, req->ie_len);
  memcpy(__entry->ht_capa, &req->ht_capa, sizeof(req->ht_capa));
  memcpy(__entry->ht_capa_mask, &req->ht_capa_mask,
         sizeof(req->ht_capa_mask));
  memcpy(__entry->vht_capa, &req->vht_capa, sizeof(req->vht_capa));
  memcpy(__entry->vht_capa_mask, &req->vht_capa_mask,
         sizeof(req->vht_capa_mask));
  if (req->fils_kek)
   memcpy(__get_dynamic_array(fils_kek),
          req->fils_kek, req->fils_kek_len);
  if (req->fils_nonces)
   memcpy(__get_dynamic_array(fils_nonces),
          req->fils_nonces, 2 * FILS_NONCE_LEN);
  __entry->ext_mld_capa_ops = req->ext_mld_capa_ops;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
    ", previous bssid: %pM, use mfp: %s, flags: 0x%x",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
    __entry->prev_bssid, BOOL_TO_STR(__entry->use_mfp),
    __entry->flags)
);

TRACE_EVENT(rdev_deauth,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_deauth_request *req),
 TP_ARGS(wiphy, netdev, req),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(bssid)
  __field(u16, reason_code)
  __field(bool, local_state_change)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(bssid, req->bssid);
  __entry->reason_code = req->reason_code;
  __entry->local_state_change = req->local_state_change;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, reason: %u, local_state_change:%d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
    __entry->reason_code, __entry->local_state_change)
);

TRACE_EVENT(rdev_disassoc,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_disassoc_request *req),
 TP_ARGS(wiphy, netdev, req),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(bssid)
  __field(u16, reason_code)
  __field(bool, local_state_change)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(bssid, req->ap_addr);
  __entry->reason_code = req->reason_code;
  __entry->local_state_change = req->local_state_change;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
    ", reason: %u, local state change: %s",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
    __entry->reason_code,
    BOOL_TO_STR(__entry->local_state_change))
);

TRACE_EVENT(rdev_mgmt_tx_cancel_wait,
 TP_PROTO(struct wiphy *wiphy,
   struct wireless_dev *wdev, u64 cookie),
 TP_ARGS(wiphy, wdev, cookie),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  __field(u64, cookie)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  __entry->cookie = cookie;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ",
    WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
);

TRACE_EVENT(rdev_set_power_mgmt,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   bool enabled, int timeout),
 TP_ARGS(wiphy, netdev, enabled, timeout),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(bool, enabled)
  __field(int, timeout)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->enabled = enabled;
  __entry->timeout = timeout;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ",
    WIPHY_PR_ARG, NETDEV_PR_ARG,
    __entry->enabled ? "" : "not ", __entry->timeout)
);

TRACE_EVENT(rdev_connect,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_connect_params *sme),
 TP_ARGS(wiphy, netdev, sme),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(bssid)
  __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
  __field(enum nl80211_auth_type, auth_type)
  __field(bool, privacy)
  __field(u32, wpa_versions)
  __field(u32, flags)
  MAC_ENTRY(prev_bssid)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(bssid, sme->bssid);
  memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
  memcpy(__entry->ssid, sme->ssid, sme->ssid_len);
  __entry->auth_type = sme->auth_type;
  __entry->privacy = sme->privacy;
  __entry->wpa_versions = sme->crypto.wpa_versions;
  __entry->flags = sme->flags;
  MAC_ASSIGN(prev_bssid, sme->prev_bssid);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
    ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, "
    "flags: 0x%x, previous bssid: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid,
    __entry->auth_type, BOOL_TO_STR(__entry->privacy),
    __entry->wpa_versions, __entry->flags, __entry->prev_bssid)
);

TRACE_EVENT(rdev_update_connect_params,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_connect_params *sme, u32 changed),
 TP_ARGS(wiphy, netdev, sme, changed),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(u32, changed)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->changed = changed;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", parameters changed: %u",
    WIPHY_PR_ARG, NETDEV_PR_ARG,  __entry->changed)
);

TRACE_EVENT(rdev_set_cqm_rssi_config,
 TP_PROTO(struct wiphy *wiphy,
   struct net_device *netdev, s32 rssi_thold,
   u32 rssi_hyst),
 TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(s32, rssi_thold)
  __field(u32, rssi_hyst)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->rssi_thold = rssi_thold;
  __entry->rssi_hyst = rssi_hyst;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
    ", rssi_thold: %d, rssi_hyst: %u ",
    WIPHY_PR_ARG, NETDEV_PR_ARG,
   __entry->rssi_thold, __entry->rssi_hyst)
);

TRACE_EVENT(rdev_set_cqm_rssi_range_config,
 TP_PROTO(struct wiphy *wiphy,
   struct net_device *netdev, s32 low, s32 high),
 TP_ARGS(wiphy, netdev, low, high),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(s32, rssi_low)
  __field(s32, rssi_high)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->rssi_low = low;
  __entry->rssi_high = high;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
    ", range: %d - %d ",
    WIPHY_PR_ARG, NETDEV_PR_ARG,
    __entry->rssi_low, __entry->rssi_high)
);

TRACE_EVENT(rdev_set_cqm_txe_config,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate,
   u32 pkts, u32 intvl),
 TP_ARGS(wiphy, netdev, rate, pkts, intvl),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(u32, rate)
  __field(u32, pkts)
  __field(u32, intvl)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->rate = rate;
  __entry->pkts = pkts;
  __entry->intvl = intvl;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts,
    __entry->intvl)
);

TRACE_EVENT(rdev_disconnect,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   u16 reason_code),
 TP_ARGS(wiphy, netdev, reason_code),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(u16, reason_code)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->reason_code = reason_code;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG,
    NETDEV_PR_ARG, __entry->reason_code)
);

TRACE_EVENT(rdev_join_ibss,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_ibss_params *params),
 TP_ARGS(wiphy, netdev, params),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(bssid)
  __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(bssid, params->bssid);
  memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
  memcpy(__entry->ssid, params->ssid, params->ssid_len);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, ssid: %s",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid)
);

TRACE_EVENT(rdev_join_ocb,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   const struct ocb_setup *setup),
 TP_ARGS(wiphy, netdev, setup),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
    WIPHY_PR_ARG, NETDEV_PR_ARG)
);

TRACE_EVENT(rdev_set_wiphy_params,
 TP_PROTO(struct wiphy *wiphy, int radio_idx, u32 changed),
 TP_ARGS(wiphy, radio_idx, changed),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, radio_idx)
  __field(u32, changed)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->radio_idx = radio_idx;
  __entry->changed = changed;
 ),
 TP_printk(WIPHY_PR_FMT ", radio_idx: %d, changed: %u",
    WIPHY_PR_ARG, __entry->radio_idx, __entry->changed)
);

DECLARE_EVENT_CLASS(wiphy_wdev_link_evt,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
   unsigned int link_id),
 TP_ARGS(wiphy, wdev, link_id),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  __field(unsigned int, link_id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  __entry->link_id = link_id;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", link_id: %u",
    WIPHY_PR_ARG, WDEV_PR_ARG, __entry->link_id)
);

TRACE_EVENT(rdev_get_tx_power,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
   int radio_idx, unsigned int link_id),
 TP_ARGS(wiphy, wdev, radio_idx, link_id),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  __field(int, radio_idx)
  __field(unsigned int, link_id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  __entry->radio_idx = radio_idx;
  __entry->link_id = link_id;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
    ", radio_idx: %d, link_id: %u",
    WIPHY_PR_ARG, WDEV_PR_ARG,
    __entry->radio_idx, __entry->link_id)
);

TRACE_EVENT(rdev_set_tx_power,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
   int radio_idx, enum nl80211_tx_power_setting type,
   int mbm),
 TP_ARGS(wiphy, wdev, radio_idx, type, mbm),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  __field(int, radio_idx)
  __field(enum nl80211_tx_power_setting, type)
  __field(int, mbm)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  __entry->radio_idx = radio_idx;
  __entry->type = type;
  __entry->mbm = mbm;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
    ", radio_idx: %d, type: %u, mbm: %d",
    WIPHY_PR_ARG, WDEV_PR_ARG,
    __entry->radio_idx, __entry->type, __entry->mbm)
);

TRACE_EVENT(rdev_return_int_int,
 TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill),
 TP_ARGS(wiphy, func_ret, func_fill),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, func_ret)
  __field(int, func_fill)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->func_ret = func_ret;
  __entry->func_fill = func_fill;
 ),
 TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d",
    WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill)
);

#ifdef CONFIG_NL80211_TESTMODE
TRACE_EVENT(rdev_testmode_cmd,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
 TP_ARGS(wiphy, wdev),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
);

TRACE_EVENT(rdev_testmode_dump,
 TP_PROTO(struct wiphy *wiphy),
 TP_ARGS(wiphy),
 TP_STRUCT__entry(
  WIPHY_ENTRY
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
 ),
 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
);
#endif /* CONFIG_NL80211_TESTMODE */

TRACE_EVENT(rdev_set_bitrate_mask,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   unsigned int link_id,
   const u8 *peer, const struct cfg80211_bitrate_mask *mask),
 TP_ARGS(wiphy, netdev, link_id, peer, mask),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(unsigned int, link_id)
  MAC_ENTRY(peer)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->link_id = link_id;
  MAC_ASSIGN(peer, peer);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, peer: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
    __entry->peer)
);

TRACE_EVENT(rdev_update_mgmt_frame_registrations,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
   struct mgmt_frame_regs *upd),
 TP_ARGS(wiphy, wdev, upd),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  __field(u16, global_stypes)
  __field(u16, interface_stypes)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  __entry->global_stypes = upd->global_stypes;
  __entry->interface_stypes = upd->interface_stypes;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", global: 0x%.2x, intf: 0x%.2x",
    WIPHY_PR_ARG, WDEV_PR_ARG,
    __entry->global_stypes, __entry->interface_stypes)
);

TRACE_EVENT(rdev_return_int_tx_rx,
 TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx),
 TP_ARGS(wiphy, ret, tx, rx),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, ret)
  __field(u32, tx)
  __field(u32, rx)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->ret = ret;
  __entry->tx = tx;
  __entry->rx = rx;
 ),
 TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u",
    WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx)
);

TRACE_EVENT(rdev_return_void_tx_rx,
 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max,
   u32 rx, u32 rx_max),
 TP_ARGS(wiphy, tx, tx_max, rx, rx_max),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(u32, tx)
  __field(u32, tx_max)
  __field(u32, rx)
  __field(u32, rx_max)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->tx = tx;
  __entry->tx_max = tx_max;
  __entry->rx = rx;
  __entry->rx_max = rx_max;
 ),
 TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ",
    WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx,
    __entry->rx_max)
);

TRACE_EVENT(rdev_set_antenna,
 TP_PROTO(struct wiphy *wiphy, int radio_idx, u32 tx, u32 rx),
 TP_ARGS(wiphy, radio_idx, tx, rx),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, radio_idx)
  __field(u32, tx)
  __field(u32, rx)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->radio_idx = radio_idx;
  __entry->tx = tx;
  __entry->rx = rx;
 ),
 TP_printk(WIPHY_PR_FMT ", radio_idx: %d, tx: %u, rx: %u ",
    WIPHY_PR_ARG, __entry->radio_idx,
    __entry->tx, __entry->rx)
);

DECLARE_EVENT_CLASS(wiphy_netdev_id_evt,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
 TP_ARGS(wiphy, netdev, id),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(u64, id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->id = id;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", id: %llu",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->id)
);

DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
 TP_ARGS(wiphy, netdev, id)
);

DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
 TP_ARGS(wiphy, netdev, id)
);

TRACE_EVENT(rdev_tdls_mgmt,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   u8 *peer, int link_id, u8 action_code, u8 dialog_token,
   u16 status_code, u32 peer_capability,
   bool initiator, const u8 *buf, size_t len),
 TP_ARGS(wiphy, netdev, peer, link_id, action_code, dialog_token,
  status_code, peer_capability, initiator, buf, len),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(peer)
  __field(int, link_id)
  __field(u8, action_code)
  __field(u8, dialog_token)
  __field(u16, status_code)
  __field(u32, peer_capability)
  __field(bool, initiator)
  __dynamic_array(u8, buf, len)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(peer, peer);
  __entry->link_id = link_id;
  __entry->action_code = action_code;
  __entry->dialog_token = dialog_token;
  __entry->status_code = status_code;
  __entry->peer_capability = peer_capability;
  __entry->initiator = initiator;
  memcpy(__get_dynamic_array(buf), buf, len);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM"
    ", link_id: %d, action_code: %u "
    "dialog_token: %u, status_code: %u, peer_capability: %u "
    "initiator: %s buf: %#.2x ",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer,
    __entry->link_id, __entry->action_code, __entry->dialog_token,
    __entry->status_code, __entry->peer_capability,
    BOOL_TO_STR(__entry->initiator),
    ((u8 *)__get_dynamic_array(buf))[0])
);

TRACE_EVENT(rdev_dump_survey,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx),
 TP_ARGS(wiphy, netdev, _idx),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(int, idx)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->idx = _idx;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx)
);

TRACE_EVENT(rdev_return_int_survey_info,
 TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info),
 TP_ARGS(wiphy, ret, info),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  CHAN_ENTRY
  __field(int, ret)
  __field(u64, time)
  __field(u64, time_busy)
  __field(u64, time_ext_busy)
  __field(u64, time_rx)
  __field(u64, time_tx)
  __field(u64, time_scan)
  __field(u32, filled)
  __field(s8, noise)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  CHAN_ASSIGN(info->channel);
  __entry->ret = ret;
  __entry->time = info->time;
  __entry->time_busy = info->time_busy;
  __entry->time_ext_busy = info->time_ext_busy;
  __entry->time_rx = info->time_rx;
  __entry->time_tx = info->time_tx;
  __entry->time_scan = info->time_scan;
  __entry->filled = info->filled;
  __entry->noise = info->noise;
 ),
 TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT
    ", channel time: %llu, channel time busy: %llu, "
    "channel time extension busy: %llu, channel time rx: %llu, "
    "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d",
    WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG,
    __entry->time, __entry->time_busy,
    __entry->time_ext_busy, __entry->time_rx,
    __entry->time_tx, __entry->time_scan,
    __entry->filled, __entry->noise)
);

TRACE_EVENT(rdev_tdls_oper,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   u8 *peer, enum nl80211_tdls_operation oper),
 TP_ARGS(wiphy, netdev, peer, oper),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(peer)
  __field(enum nl80211_tdls_operation, oper)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(peer, peer);
  __entry->oper = oper;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, oper: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper)
);

DECLARE_EVENT_CLASS(rdev_pmksa,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_pmksa *pmksa),
 TP_ARGS(wiphy, netdev, pmksa),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(bssid)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(bssid, pmksa->bssid);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid)
);

TRACE_EVENT(rdev_probe_client,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   const u8 *peer),
 TP_ARGS(wiphy, netdev, peer),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(peer)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(peer, peer);
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer)
);

DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_pmksa *pmksa),
 TP_ARGS(wiphy, netdev, pmksa)
);

DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   struct cfg80211_pmksa *pmksa),
 TP_ARGS(wiphy, netdev, pmksa)
);

TRACE_EVENT(rdev_remain_on_channel,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
   struct ieee80211_channel *chan,
   unsigned int duration),
 TP_ARGS(wiphy, wdev, chan, duration),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  CHAN_ENTRY
  __field(unsigned int, duration)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  CHAN_ASSIGN(chan);
  __entry->duration = duration;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u",
    WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration)
);

TRACE_EVENT(rdev_return_int_cookie,
 TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie),
 TP_ARGS(wiphy, ret, cookie),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  __field(int, ret)
  __field(u64, cookie)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  __entry->ret = ret;
  __entry->cookie = cookie;
 ),
 TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu",
    WIPHY_PR_ARG, __entry->ret, __entry->cookie)
);

TRACE_EVENT(rdev_cancel_remain_on_channel,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
 TP_ARGS(wiphy, wdev, cookie),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  __field(u64, cookie)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  __entry->cookie = cookie;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu",
    WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
);

TRACE_EVENT(rdev_mgmt_tx,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
   struct cfg80211_mgmt_tx_params *params),
 TP_ARGS(wiphy, wdev, params),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  WDEV_ENTRY
  CHAN_ENTRY
  __field(bool, offchan)
  __field(unsigned int, wait)
  __field(bool, no_cck)
  __field(bool, dont_wait_for_ack)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  WDEV_ASSIGN;
  CHAN_ASSIGN(params->chan);
  __entry->offchan = params->offchan;
  __entry->wait = params->wait;
  __entry->no_cck = params->no_cck;
  __entry->dont_wait_for_ack = params->dont_wait_for_ack;
 ),
 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s,"
    " wait: %u, no cck: %s, dont wait for ack: %s",
    WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG,
    BOOL_TO_STR(__entry->offchan), __entry->wait,
    BOOL_TO_STR(__entry->no_cck),
    BOOL_TO_STR(__entry->dont_wait_for_ack))
);

TRACE_EVENT(rdev_tx_control_port,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   const u8 *buf, size_t len, const u8 *dest, __be16 proto,
   bool unencrypted, int link_id),
 TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted, link_id),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  MAC_ENTRY(dest)
  __field(__be16, proto)
  __field(bool, unencrypted)
  __field(int, link_id)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  MAC_ASSIGN(dest, dest);
  __entry->proto = proto;
  __entry->unencrypted = unencrypted;
  __entry->link_id = link_id;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM,"
    " proto: 0x%x, unencrypted: %s, link: %d",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest,
    be16_to_cpu(__entry->proto),
    BOOL_TO_STR(__entry->unencrypted),
    __entry->link_id)
);

TRACE_EVENT(rdev_set_noack_map,
 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
   u16 noack_map),
 TP_ARGS(wiphy, netdev, noack_map),
 TP_STRUCT__entry(
  WIPHY_ENTRY
  NETDEV_ENTRY
  __field(u16, noack_map)
 ),
 TP_fast_assign(
  WIPHY_ASSIGN;
  NETDEV_ASSIGN;
  __entry->noack_map = noack_map;
 ),
 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u",
    WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map)
);
DEFINE_EVENT(wiphy_wdev_link_evt, rdev_get_channel,
 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
--> --------------------

--> maximum size reached

--> --------------------