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