cfg80211: add tracing for P2P Device start/stop
[linux-3.10.git] / net / wireless / trace.h
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 <net/cfg80211.h>
11 #include "core.h"
12
13 #define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN)
14 #define MAC_ASSIGN(entry_mac, given_mac) do {                        \
15         if (given_mac)                                               \
16                 memcpy(__entry->entry_mac, given_mac, ETH_ALEN);     \
17         else                                                         \
18                 memset(__entry->entry_mac, 0, ETH_ALEN);             \
19         } while (0)
20 #define MAC_PR_FMT "%pM"
21 #define MAC_PR_ARG(entry_mac) (__entry->entry_mac)
22
23 #define WIPHY_ENTRY MAC_ENTRY(wiphy_mac)
24 #define WIPHY_ASSIGN MAC_ASSIGN(wiphy_mac, wiphy->perm_addr)
25 #define WIPHY_PR_FMT "wiphy " MAC_PR_FMT
26 #define WIPHY_PR_ARG MAC_PR_ARG(wiphy_mac)
27
28 #define WDEV_ENTRY __field(u32, id)
29 #define WDEV_ASSIGN (__entry->id) = (wdev->identifier)
30 #define WDEV_PR_FMT ", wdev id: %u"
31 #define WDEV_PR_ARG (__entry->id)
32
33 #define NETDEV_ENTRY __array(char, name, IFNAMSIZ) \
34                      MAC_ENTRY(netdev_addr)        \
35                      __field(int, ifindex)
36 #define NETDEV_ASSIGN                                          \
37         do {                                                   \
38                 memcpy(__entry->name, netdev->name, IFNAMSIZ); \
39                 MAC_ASSIGN(netdev_addr, netdev->dev_addr);     \
40                 (__entry->ifindex) = (netdev->ifindex);        \
41         } while (0)
42 #define NETDEV_PR_FMT ", netdev - name: %s, addr: " MAC_PR_FMT \
43                       ", intf index: %d"
44 #define NETDEV_PR_ARG (__entry->name), MAC_PR_ARG(netdev_addr), \
45                       (__entry->ifindex)
46
47 #define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout)                 \
48                        __field(u16, dot11MeshConfirmTimeout)               \
49                        __field(u16, dot11MeshHoldingTimeout)               \
50                        __field(u16, dot11MeshMaxPeerLinks)                 \
51                        __field(u8, dot11MeshMaxRetries)                    \
52                        __field(u8, dot11MeshTTL)                           \
53                        __field(u8, element_ttl)                            \
54                        __field(bool, auto_open_plinks)                     \
55                        __field(u32, dot11MeshNbrOffsetMaxNeighbor)         \
56                        __field(u8, dot11MeshHWMPmaxPREQretries)            \
57                        __field(u32, path_refresh_time)                     \
58                        __field(u32, dot11MeshHWMPactivePathTimeout)        \
59                        __field(u16, min_discovery_timeout)                 \
60                        __field(u16, dot11MeshHWMPpreqMinInterval)          \
61                        __field(u16, dot11MeshHWMPperrMinInterval)          \
62                        __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \
63                        __field(u8, dot11MeshHWMPRootMode)                  \
64                        __field(u16, dot11MeshHWMPRannInterval)             \
65                        __field(bool, dot11MeshGateAnnouncementProtocol)    \
66                        __field(bool, dot11MeshForwarding)                  \
67                        __field(s32, rssi_threshold)                        \
68                        __field(u16, ht_opmode)                             \
69                        __field(u32, dot11MeshHWMPactivePathToRootTimeout)  \
70                        __field(u16, dot11MeshHWMProotInterval)             \
71                        __field(u16, dot11MeshHWMPconfirmationInterval)
72 #define MESH_CFG_ASSIGN                                                       \
73         do {                                                                  \
74                 __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \
75                 __entry->dot11MeshConfirmTimeout =                            \
76                                 conf->dot11MeshConfirmTimeout;                \
77                 __entry->dot11MeshHoldingTimeout =                            \
78                                 conf->dot11MeshHoldingTimeout;                \
79                 __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \
80                 __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries;     \
81                 __entry->dot11MeshTTL = conf->dot11MeshTTL;                   \
82                 __entry->element_ttl = conf->element_ttl;                     \
83                 __entry->auto_open_plinks = conf->auto_open_plinks;           \
84                 __entry->dot11MeshNbrOffsetMaxNeighbor =                      \
85                                 conf->dot11MeshNbrOffsetMaxNeighbor;          \
86                 __entry->dot11MeshHWMPmaxPREQretries =                        \
87                                 conf->dot11MeshHWMPmaxPREQretries;            \
88                 __entry->path_refresh_time = conf->path_refresh_time;         \
89                 __entry->dot11MeshHWMPactivePathTimeout =                     \
90                                 conf->dot11MeshHWMPactivePathTimeout;         \
91                 __entry->min_discovery_timeout = conf->min_discovery_timeout; \
92                 __entry->dot11MeshHWMPpreqMinInterval =                       \
93                                 conf->dot11MeshHWMPpreqMinInterval;           \
94                 __entry->dot11MeshHWMPperrMinInterval =                       \
95                                 conf->dot11MeshHWMPperrMinInterval;           \
96                 __entry->dot11MeshHWMPnetDiameterTraversalTime =              \
97                                 conf->dot11MeshHWMPnetDiameterTraversalTime;  \
98                 __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \
99                 __entry->dot11MeshHWMPRannInterval =                          \
100                                 conf->dot11MeshHWMPRannInterval;              \
101                 __entry->dot11MeshGateAnnouncementProtocol =                  \
102                                 conf->dot11MeshGateAnnouncementProtocol;      \
103                 __entry->dot11MeshForwarding = conf->dot11MeshForwarding;     \
104                 __entry->rssi_threshold = conf->rssi_threshold;               \
105                 __entry->ht_opmode = conf->ht_opmode;                         \
106                 __entry->dot11MeshHWMPactivePathToRootTimeout =               \
107                                 conf->dot11MeshHWMPactivePathToRootTimeout;   \
108                 __entry->dot11MeshHWMProotInterval =                          \
109                                 conf->dot11MeshHWMProotInterval;              \
110                 __entry->dot11MeshHWMPconfirmationInterval =                  \
111                                 conf->dot11MeshHWMPconfirmationInterval;      \
112         } while (0)
113
114 #define CHAN_ENTRY __field(enum ieee80211_band, band) \
115                    __field(u16, center_freq)
116 #define CHAN_ASSIGN(chan)                                         \
117         do {                                                      \
118                 if (chan) {                                       \
119                         __entry->band = chan->band;               \
120                         __entry->center_freq = chan->center_freq; \
121                 } else {                                          \
122                         __entry->band = 0;                        \
123                         __entry->center_freq = 0;                 \
124                 }                                                 \
125         } while (0)
126 #define CHAN_PR_FMT ", band: %d, freq: %u"
127 #define CHAN_PR_ARG __entry->band, __entry->center_freq
128
129 #define SINFO_ENTRY __field(int, generation)        \
130                     __field(u32, connected_time)    \
131                     __field(u32, inactive_time)     \
132                     __field(u32, rx_bytes)          \
133                     __field(u32, tx_bytes)          \
134                     __field(u32, rx_packets)        \
135                     __field(u32, tx_packets)        \
136                     __field(u32, tx_retries)        \
137                     __field(u32, tx_failed)         \
138                     __field(u32, rx_dropped_misc)   \
139                     __field(u32, beacon_loss_count) \
140                     __field(u16, llid)              \
141                     __field(u16, plid)              \
142                     __field(u8, plink_state)
143 #define SINFO_ASSIGN                                                   \
144         do {                                                           \
145                 __entry->generation = sinfo->generation;               \
146                 __entry->connected_time = sinfo->connected_time;       \
147                 __entry->inactive_time = sinfo->inactive_time;         \
148                 __entry->rx_bytes = sinfo->rx_bytes;                   \
149                 __entry->tx_bytes = sinfo->tx_bytes;                   \
150                 __entry->rx_packets = sinfo->rx_packets;               \
151                 __entry->tx_packets = sinfo->tx_packets;               \
152                 __entry->tx_retries = sinfo->tx_retries;               \
153                 __entry->tx_failed = sinfo->tx_failed;                 \
154                 __entry->rx_dropped_misc = sinfo->rx_dropped_misc;     \
155                 __entry->beacon_loss_count = sinfo->beacon_loss_count; \
156                 __entry->llid = sinfo->llid;                           \
157                 __entry->plid = sinfo->plid;                           \
158                 __entry->plink_state = sinfo->plink_state;             \
159         } while (0)
160
161 #define BOOL_TO_STR(bo) (bo) ? "true" : "false"
162
163 /*************************************************************
164  *                      rdev->ops traces                     *
165  *************************************************************/
166
167 TRACE_EVENT(rdev_suspend,
168         TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow),
169         TP_ARGS(wiphy, wow),
170         TP_STRUCT__entry(
171                 WIPHY_ENTRY
172                 __field(bool, any)
173                 __field(bool, disconnect)
174                 __field(bool, magic_pkt)
175                 __field(bool, gtk_rekey_failure)
176                 __field(bool, eap_identity_req)
177                 __field(bool, four_way_handshake)
178                 __field(bool, rfkill_release)
179                 __field(bool, valid_wow)
180         ),
181         TP_fast_assign(
182                 WIPHY_ASSIGN;
183                 if (wow) {
184                         __entry->any = wow->any;
185                         __entry->disconnect = wow->disconnect;
186                         __entry->magic_pkt = wow->magic_pkt;
187                         __entry->gtk_rekey_failure = wow->gtk_rekey_failure;
188                         __entry->eap_identity_req = wow->eap_identity_req;
189                         __entry->four_way_handshake = wow->four_way_handshake;
190                         __entry->rfkill_release = wow->rfkill_release;
191                         __entry->valid_wow = true;
192                 } else {
193                         __entry->valid_wow = false;
194                 }
195         ),
196         TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, "
197                   "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, "
198                   "four way handshake: %d, rfkill release: %d.",
199                   WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)",
200                   __entry->any, __entry->disconnect, __entry->magic_pkt,
201                   __entry->gtk_rekey_failure, __entry->eap_identity_req,
202                   __entry->four_way_handshake, __entry->rfkill_release)
203 );
204
205 TRACE_EVENT(rdev_return_int,
206         TP_PROTO(struct wiphy *wiphy, int ret),
207         TP_ARGS(wiphy, ret),
208         TP_STRUCT__entry(
209                 WIPHY_ENTRY
210                 __field(int, ret)
211         ),
212         TP_fast_assign(
213                 WIPHY_ASSIGN;
214                 __entry->ret = ret;
215         ),
216         TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret)
217 );
218
219 TRACE_EVENT(rdev_scan,
220         TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request),
221         TP_ARGS(wiphy, request),
222         TP_STRUCT__entry(
223                 WIPHY_ENTRY
224         ),
225         TP_fast_assign(
226                 WIPHY_ASSIGN;
227         ),
228         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
229 );
230
231 DECLARE_EVENT_CLASS(wiphy_only_evt,
232         TP_PROTO(struct wiphy *wiphy),
233         TP_ARGS(wiphy),
234         TP_STRUCT__entry(
235                 WIPHY_ENTRY
236         ),
237         TP_fast_assign(
238                 WIPHY_ASSIGN;
239         ),
240         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
241 );
242
243 DEFINE_EVENT(wiphy_only_evt, rdev_resume,
244         TP_PROTO(struct wiphy *wiphy),
245         TP_ARGS(wiphy)
246 );
247
248 DEFINE_EVENT(wiphy_only_evt, rdev_return_void,
249         TP_PROTO(struct wiphy *wiphy),
250         TP_ARGS(wiphy)
251 );
252
253 DEFINE_EVENT(wiphy_only_evt, rdev_get_ringparam,
254         TP_PROTO(struct wiphy *wiphy),
255         TP_ARGS(wiphy)
256 );
257
258 DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna,
259         TP_PROTO(struct wiphy *wiphy),
260         TP_ARGS(wiphy)
261 );
262
263 DEFINE_EVENT(wiphy_only_evt, rdev_get_tx_power,
264         TP_PROTO(struct wiphy *wiphy),
265         TP_ARGS(wiphy)
266 );
267
268 DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll,
269         TP_PROTO(struct wiphy *wiphy),
270         TP_ARGS(wiphy)
271 );
272
273 DECLARE_EVENT_CLASS(wiphy_enabled_evt,
274         TP_PROTO(struct wiphy *wiphy, bool enabled),
275         TP_ARGS(wiphy, enabled),
276         TP_STRUCT__entry(
277                 WIPHY_ENTRY
278                 __field(bool, enabled)
279         ),
280         TP_fast_assign(
281                 WIPHY_ASSIGN;
282                 __entry->enabled = enabled;
283         ),
284         TP_printk(WIPHY_PR_FMT ", %senabled ",
285                   WIPHY_PR_ARG, __entry->enabled ? "" : "not ")
286 );
287
288 DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup,
289         TP_PROTO(struct wiphy *wiphy, bool enabled),
290         TP_ARGS(wiphy, enabled)
291 );
292
293 TRACE_EVENT(rdev_add_virtual_intf,
294         TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type),
295         TP_ARGS(wiphy, name, type),
296         TP_STRUCT__entry(
297                 WIPHY_ENTRY
298                 __string(vir_intf_name, name ? name : "<noname>")
299                 __field(enum nl80211_iftype, type)
300         ),
301         TP_fast_assign(
302                 WIPHY_ASSIGN;
303                 __assign_str(vir_intf_name, name ? name : "<noname>");
304                 __entry->type = type;
305         ),
306         TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d",
307                   WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type)
308 );
309
310 DECLARE_EVENT_CLASS(wiphy_wdev_evt,
311         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
312         TP_ARGS(wiphy, wdev),
313         TP_STRUCT__entry(
314                 WIPHY_ENTRY
315                 WDEV_ENTRY
316         ),
317         TP_fast_assign(
318                 WIPHY_ASSIGN;
319                 WDEV_ASSIGN;
320         ),
321         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
322 );
323
324 DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev,
325         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
326         TP_ARGS(wiphy, wdev)
327 );
328
329 DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf,
330         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
331         TP_ARGS(wiphy, wdev)
332 );
333
334 TRACE_EVENT(rdev_change_virtual_intf,
335         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
336                  enum nl80211_iftype type),
337         TP_ARGS(wiphy, netdev, type),
338         TP_STRUCT__entry(
339                 WIPHY_ENTRY
340                 NETDEV_ENTRY
341                 __field(enum nl80211_iftype, type)
342         ),
343         TP_fast_assign(
344                 WIPHY_ASSIGN;
345                 NETDEV_ASSIGN;
346                 __entry->type = type;
347         ),
348         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", type: %d",
349                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type)
350 );
351
352 DECLARE_EVENT_CLASS(key_handle,
353         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
354                  bool pairwise, const u8 *mac_addr),
355         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr),
356         TP_STRUCT__entry(
357                 WIPHY_ENTRY
358                 NETDEV_ENTRY
359                 MAC_ENTRY(mac_addr)
360                 __field(u8, key_index)
361                 __field(bool, pairwise)
362         ),
363         TP_fast_assign(
364                 WIPHY_ASSIGN;
365                 NETDEV_ASSIGN;
366                 MAC_ASSIGN(mac_addr, mac_addr);
367                 __entry->key_index = key_index;
368                 __entry->pairwise = pairwise;
369         ),
370         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", key_index: %u, pairwise: %s, mac addr: " MAC_PR_FMT,
371                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
372                   BOOL_TO_STR(__entry->pairwise), MAC_PR_ARG(mac_addr))
373 );
374
375 DEFINE_EVENT(key_handle, rdev_add_key,
376         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
377                  bool pairwise, const u8 *mac_addr),
378         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
379 );
380
381 DEFINE_EVENT(key_handle, rdev_get_key,
382         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
383                  bool pairwise, const u8 *mac_addr),
384         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
385 );
386
387 DEFINE_EVENT(key_handle, rdev_del_key,
388         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
389                  bool pairwise, const u8 *mac_addr),
390         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
391 );
392
393 TRACE_EVENT(rdev_set_default_key,
394         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
395                  bool unicast, bool multicast),
396         TP_ARGS(wiphy, netdev, key_index, unicast, multicast),
397         TP_STRUCT__entry(
398                 WIPHY_ENTRY
399                 NETDEV_ENTRY
400                 __field(u8, key_index)
401                 __field(bool, unicast)
402                 __field(bool, multicast)
403         ),
404         TP_fast_assign(
405                 WIPHY_ASSIGN;
406                 NETDEV_ASSIGN;
407                 __entry->key_index = key_index;
408                 __entry->unicast = unicast;
409                 __entry->multicast = multicast;
410         ),
411         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", key index: %u, unicast: %s, multicast: %s",
412                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
413                   BOOL_TO_STR(__entry->unicast),
414                   BOOL_TO_STR(__entry->multicast))
415 );
416
417 TRACE_EVENT(rdev_set_default_mgmt_key,
418         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index),
419         TP_ARGS(wiphy, netdev, key_index),
420         TP_STRUCT__entry(
421                 WIPHY_ENTRY
422                 NETDEV_ENTRY
423                 __field(u8, key_index)
424         ),
425         TP_fast_assign(
426                 WIPHY_ASSIGN;
427                 NETDEV_ASSIGN;
428                 __entry->key_index = key_index;
429         ),
430         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", key index: %u",
431                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index)
432 );
433
434 TRACE_EVENT(rdev_start_ap,
435         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
436                  struct cfg80211_ap_settings *settings),
437         TP_ARGS(wiphy, netdev, settings),
438         TP_STRUCT__entry(
439                 WIPHY_ENTRY
440                 NETDEV_ENTRY
441                 CHAN_ENTRY
442                 __field(int, beacon_interval)
443                 __field(int, dtim_period)
444                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
445                 __field(enum nl80211_hidden_ssid, hidden_ssid)
446                 __field(u32, wpa_ver)
447                 __field(bool, privacy)
448                 __field(enum nl80211_auth_type, auth_type)
449                 __field(int, inactivity_timeout)
450         ),
451         TP_fast_assign(
452                 WIPHY_ASSIGN;
453                 NETDEV_ASSIGN;
454                 CHAN_ASSIGN(settings->channel);
455                 __entry->beacon_interval = settings->beacon_interval;
456                 __entry->dtim_period = settings->dtim_period;
457                 __entry->hidden_ssid = settings->hidden_ssid;
458                 __entry->wpa_ver = settings->crypto.wpa_versions;
459                 __entry->privacy = settings->privacy;
460                 __entry->auth_type = settings->auth_type;
461                 __entry->inactivity_timeout = settings->inactivity_timeout;
462                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
463                 memcpy(__entry->ssid, settings->ssid, settings->ssid_len);
464         ),
465         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", AP settings - ssid: %s, "
466                   CHAN_PR_FMT ", beacon interval: %d, dtim period: %d, "
467                   "hidden ssid: %d, wpa versions: %u, privacy: %s, "
468                   "auth type: %d, inactivity timeout: %d",
469                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_PR_ARG,
470                   __entry->beacon_interval, __entry->dtim_period,
471                   __entry->hidden_ssid, __entry->wpa_ver,
472                   BOOL_TO_STR(__entry->privacy), __entry->auth_type,
473                   __entry->inactivity_timeout)
474 );
475
476 TRACE_EVENT(rdev_change_beacon,
477         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
478                  struct cfg80211_beacon_data *info),
479         TP_ARGS(wiphy, netdev, info),
480         TP_STRUCT__entry(
481                 WIPHY_ENTRY
482                 NETDEV_ENTRY
483                 __dynamic_array(u8, head, info ? info->head_len : 0)
484                 __dynamic_array(u8, tail, info ? info->tail_len : 0)
485                 __dynamic_array(u8, beacon_ies, info ? info->beacon_ies_len : 0)
486                 __dynamic_array(u8, proberesp_ies,
487                                 info ? info->proberesp_ies_len : 0)
488                 __dynamic_array(u8, assocresp_ies,
489                                 info ? info->assocresp_ies_len : 0)
490                 __dynamic_array(u8, probe_resp, info ? info->probe_resp_len : 0)
491         ),
492         TP_fast_assign(
493                 WIPHY_ASSIGN;
494                 NETDEV_ASSIGN;
495                 if (info) {
496                         if (info->head)
497                                 memcpy(__get_dynamic_array(head), info->head,
498                                        info->head_len);
499                         if (info->tail)
500                                 memcpy(__get_dynamic_array(tail), info->tail,
501                                        info->tail_len);
502                         if (info->beacon_ies)
503                                 memcpy(__get_dynamic_array(beacon_ies),
504                                        info->beacon_ies, info->beacon_ies_len);
505                         if (info->proberesp_ies)
506                                 memcpy(__get_dynamic_array(proberesp_ies),
507                                        info->proberesp_ies,
508                                        info->proberesp_ies_len);
509                         if (info->assocresp_ies)
510                                 memcpy(__get_dynamic_array(assocresp_ies),
511                                        info->assocresp_ies,
512                                        info->assocresp_ies_len);
513                         if (info->probe_resp)
514                                 memcpy(__get_dynamic_array(probe_resp),
515                                        info->probe_resp, info->probe_resp_len);
516                 }
517         ),
518         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
519 );
520
521 DECLARE_EVENT_CLASS(wiphy_netdev_evt,
522         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
523         TP_ARGS(wiphy, netdev),
524         TP_STRUCT__entry(
525                 WIPHY_ENTRY
526                 NETDEV_ENTRY
527         ),
528         TP_fast_assign(
529                 WIPHY_ASSIGN;
530                 NETDEV_ASSIGN;
531         ),
532         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
533 );
534
535 DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap,
536         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
537         TP_ARGS(wiphy, netdev)
538 );
539
540 DEFINE_EVENT(wiphy_netdev_evt, rdev_get_et_stats,
541         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
542         TP_ARGS(wiphy, netdev)
543 );
544
545 DEFINE_EVENT(wiphy_netdev_evt, rdev_sched_scan_stop,
546         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
547         TP_ARGS(wiphy, netdev)
548 );
549
550 DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data,
551         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
552         TP_ARGS(wiphy, netdev)
553 );
554
555 DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config,
556         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
557         TP_ARGS(wiphy, netdev)
558 );
559
560 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh,
561         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
562         TP_ARGS(wiphy, netdev)
563 );
564
565 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss,
566         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
567         TP_ARGS(wiphy, netdev)
568 );
569
570 DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa,
571         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
572         TP_ARGS(wiphy, netdev)
573 );
574
575 DECLARE_EVENT_CLASS(station_add_change,
576         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
577                  struct station_parameters *params),
578         TP_ARGS(wiphy, netdev, mac, params),
579         TP_STRUCT__entry(
580                 WIPHY_ENTRY
581                 NETDEV_ENTRY
582                 MAC_ENTRY(sta_mac)
583                 __field(u32, sta_flags_mask)
584                 __field(u32, sta_flags_set)
585                 __field(u32, sta_modify_mask)
586                 __field(int, listen_interval)
587                 __field(u16, aid)
588                 __field(u8, plink_action)
589                 __field(u8, plink_state)
590                 __field(u8, uapsd_queues)
591                 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
592         ),
593         TP_fast_assign(
594                 WIPHY_ASSIGN;
595                 NETDEV_ASSIGN;
596                 MAC_ASSIGN(sta_mac, mac);
597                 __entry->sta_flags_mask = params->sta_flags_mask;
598                 __entry->sta_flags_set = params->sta_flags_set;
599                 __entry->sta_modify_mask = params->sta_modify_mask;
600                 __entry->listen_interval = params->listen_interval;
601                 __entry->aid = params->aid;
602                 __entry->plink_action = params->plink_action;
603                 __entry->plink_state = params->plink_state;
604                 __entry->uapsd_queues = params->uapsd_queues;
605                 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
606                 if (params->ht_capa)
607                         memcpy(__entry->ht_capa, params->ht_capa,
608                                sizeof(struct ieee80211_ht_cap));
609         ),
610         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", station mac: " MAC_PR_FMT
611                   ", station flags mask: %u, station flags set: %u, "
612                   "station modify mask: %u, listen interval: %d, aid: %u, "
613                   "plink action: %u, plink state: %u, uapsd queues: %u",
614                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
615                   __entry->sta_flags_mask, __entry->sta_flags_set,
616                   __entry->sta_modify_mask, __entry->listen_interval,
617                   __entry->aid, __entry->plink_action, __entry->plink_state,
618                   __entry->uapsd_queues)
619 );
620
621 DEFINE_EVENT(station_add_change, rdev_add_station,
622         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
623                  struct station_parameters *params),
624         TP_ARGS(wiphy, netdev, mac, params)
625 );
626
627 DEFINE_EVENT(station_add_change, rdev_change_station,
628         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
629                  struct station_parameters *params),
630         TP_ARGS(wiphy, netdev, mac, params)
631 );
632
633 DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt,
634         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
635         TP_ARGS(wiphy, netdev, mac),
636         TP_STRUCT__entry(
637                 WIPHY_ENTRY
638                 NETDEV_ENTRY
639                 MAC_ENTRY(sta_mac)
640         ),
641         TP_fast_assign(
642                 WIPHY_ASSIGN;
643                 NETDEV_ASSIGN;
644                 MAC_ASSIGN(sta_mac, mac);
645         ),
646         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
647                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac))
648 );
649
650 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_station,
651         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
652         TP_ARGS(wiphy, netdev, mac)
653 );
654
655 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station,
656         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
657         TP_ARGS(wiphy, netdev, mac)
658 );
659
660 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath,
661         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
662         TP_ARGS(wiphy, netdev, mac)
663 );
664
665 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer,
666         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
667         TP_ARGS(wiphy, netdev, mac)
668 );
669
670 TRACE_EVENT(rdev_dump_station,
671         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
672                  u8 *mac),
673         TP_ARGS(wiphy, netdev, idx, mac),
674         TP_STRUCT__entry(
675                 WIPHY_ENTRY
676                 NETDEV_ENTRY
677                 MAC_ENTRY(sta_mac)
678                 __field(int, idx)
679         ),
680         TP_fast_assign(
681                 WIPHY_ASSIGN;
682                 NETDEV_ASSIGN;
683                 MAC_ASSIGN(sta_mac, mac);
684                 __entry->idx = idx;
685         ),
686         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", station mac: " MAC_PR_FMT ", idx: %d",
687                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
688                   __entry->idx)
689 );
690
691 TRACE_EVENT(rdev_return_int_station_info,
692         TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo),
693         TP_ARGS(wiphy, ret, sinfo),
694         TP_STRUCT__entry(
695                 WIPHY_ENTRY
696                 __field(int, ret)
697                 SINFO_ENTRY
698         ),
699         TP_fast_assign(
700                 WIPHY_ASSIGN;
701                 __entry->ret = ret;
702                 SINFO_ASSIGN;
703         ),
704         TP_printk(WIPHY_PR_FMT ", returned %d" ,
705                   WIPHY_PR_ARG, __entry->ret)
706 );
707
708 DECLARE_EVENT_CLASS(mpath_evt,
709         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
710                  u8 *next_hop),
711         TP_ARGS(wiphy, netdev, dst, next_hop),
712         TP_STRUCT__entry(
713                 WIPHY_ENTRY
714                 NETDEV_ENTRY
715                 MAC_ENTRY(dst)
716                 MAC_ENTRY(next_hop)
717         ),
718         TP_fast_assign(
719                 WIPHY_ASSIGN;
720                 NETDEV_ASSIGN;
721                 MAC_ASSIGN(dst, dst);
722                 MAC_ASSIGN(next_hop, next_hop);
723         ),
724         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", destination: " MAC_PR_FMT ", next hop: " MAC_PR_FMT,
725                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dst),
726                   MAC_PR_ARG(next_hop))
727 );
728
729 DEFINE_EVENT(mpath_evt, rdev_add_mpath,
730         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
731                  u8 *next_hop),
732         TP_ARGS(wiphy, netdev, dst, next_hop)
733 );
734
735 DEFINE_EVENT(mpath_evt, rdev_change_mpath,
736         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
737                  u8 *next_hop),
738         TP_ARGS(wiphy, netdev, dst, next_hop)
739 );
740
741 DEFINE_EVENT(mpath_evt, rdev_get_mpath,
742         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
743                  u8 *next_hop),
744         TP_ARGS(wiphy, netdev, dst, next_hop)
745 );
746
747 TRACE_EVENT(rdev_dump_mpath,
748         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
749                  u8 *dst, u8 *next_hop),
750         TP_ARGS(wiphy, netdev, idx, dst, next_hop),
751         TP_STRUCT__entry(
752                 WIPHY_ENTRY
753                 NETDEV_ENTRY
754                 MAC_ENTRY(dst)
755                 MAC_ENTRY(next_hop)
756                 __field(int, idx)
757         ),
758         TP_fast_assign(
759                 WIPHY_ASSIGN;
760                 NETDEV_ASSIGN;
761                 MAC_ASSIGN(dst, dst);
762                 MAC_ASSIGN(next_hop, next_hop);
763                 __entry->idx = idx;
764         ),
765         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", index: %d, destination: "
766                   MAC_PR_FMT ", next hop: " MAC_PR_FMT,
767                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, MAC_PR_ARG(dst),
768                   MAC_PR_ARG(next_hop))
769 );
770
771 TRACE_EVENT(rdev_return_int_mpath_info,
772         TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo),
773         TP_ARGS(wiphy, ret, pinfo),
774         TP_STRUCT__entry(
775                 WIPHY_ENTRY
776                 __field(int, ret)
777                 __field(int, generation)
778                 __field(u32, filled)
779                 __field(u32, frame_qlen)
780                 __field(u32, sn)
781                 __field(u32, metric)
782                 __field(u32, exptime)
783                 __field(u32, discovery_timeout)
784                 __field(u8, discovery_retries)
785                 __field(u8, flags)
786         ),
787         TP_fast_assign(
788                 WIPHY_ASSIGN;
789                 __entry->ret = ret;
790                 __entry->generation = pinfo->generation;
791                 __entry->filled = pinfo->filled;
792                 __entry->frame_qlen = pinfo->frame_qlen;
793                 __entry->sn = pinfo->sn;
794                 __entry->metric = pinfo->metric;
795                 __entry->exptime = pinfo->exptime;
796                 __entry->discovery_timeout = pinfo->discovery_timeout;
797                 __entry->discovery_retries = pinfo->discovery_retries;
798                 __entry->flags = pinfo->flags;
799         ),
800         TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, "
801                   "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u,"
802                   " discovery timeout: %u, discovery retries: %u, flags: %u",
803                   WIPHY_PR_ARG, __entry->ret, __entry->generation,
804                   __entry->filled, __entry->frame_qlen, __entry->sn,
805                   __entry->metric, __entry->exptime, __entry->discovery_timeout,
806                   __entry->discovery_retries, __entry->flags)
807 );
808
809 TRACE_EVENT(rdev_return_int_mesh_config,
810         TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf),
811         TP_ARGS(wiphy, ret, conf),
812         TP_STRUCT__entry(
813                 WIPHY_ENTRY
814                 MESH_CFG_ENTRY
815                 __field(int, ret)
816         ),
817         TP_fast_assign(
818                 WIPHY_ASSIGN;
819                 MESH_CFG_ASSIGN;
820                 __entry->ret = ret;
821         ),
822         TP_printk(WIPHY_PR_FMT ", returned: %d",
823                   WIPHY_PR_ARG, __entry->ret)
824 );
825
826 TRACE_EVENT(rdev_update_mesh_config,
827         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask,
828                  const struct mesh_config *conf),
829         TP_ARGS(wiphy, netdev, mask, conf),
830         TP_STRUCT__entry(
831                 WIPHY_ENTRY
832                 NETDEV_ENTRY
833                 MESH_CFG_ENTRY
834                 __field(u32, mask)
835         ),
836         TP_fast_assign(
837                 WIPHY_ASSIGN;
838                 NETDEV_ASSIGN;
839                 MESH_CFG_ASSIGN;
840                 __entry->mask = mask;
841         ),
842         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", mask: %u",
843                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask)
844 );
845
846 TRACE_EVENT(rdev_join_mesh,
847         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
848                  const struct mesh_config *conf,
849                  const struct mesh_setup *setup),
850         TP_ARGS(wiphy, netdev, conf, setup),
851         TP_STRUCT__entry(
852                 WIPHY_ENTRY
853                 NETDEV_ENTRY
854                 MESH_CFG_ENTRY
855         ),
856         TP_fast_assign(
857                 WIPHY_ASSIGN;
858                 NETDEV_ASSIGN;
859                 MESH_CFG_ASSIGN;
860         ),
861         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT,
862                   WIPHY_PR_ARG, NETDEV_PR_ARG)
863 );
864
865 TRACE_EVENT(rdev_change_bss,
866         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
867                  struct bss_parameters *params),
868         TP_ARGS(wiphy, netdev, params),
869         TP_STRUCT__entry(
870                 WIPHY_ENTRY
871                 NETDEV_ENTRY
872                 __field(int, use_cts_prot)
873                 __field(int, use_short_preamble)
874                 __field(int, use_short_slot_time)
875                 __field(int, ap_isolate)
876                 __field(int, ht_opmode)
877         ),
878         TP_fast_assign(
879                 WIPHY_ASSIGN;
880                 NETDEV_ASSIGN;
881                 __entry->use_cts_prot = params->use_cts_prot;
882                 __entry->use_short_preamble = params->use_short_preamble;
883                 __entry->use_short_slot_time = params->use_short_slot_time;
884                 __entry->ap_isolate = params->ap_isolate;
885                 __entry->ht_opmode = params->ht_opmode;
886         ),
887         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", use cts prot: %d, "
888                   "use short preamble: %d, use short slot time: %d, "
889                   "ap isolate: %d, ht opmode: %d",
890                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot,
891                   __entry->use_short_preamble, __entry->use_short_slot_time,
892                   __entry->ap_isolate, __entry->ht_opmode)
893 );
894
895 TRACE_EVENT(rdev_set_txq_params,
896         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
897                  struct ieee80211_txq_params *params),
898         TP_ARGS(wiphy, netdev, params),
899         TP_STRUCT__entry(
900                 WIPHY_ENTRY
901                 NETDEV_ENTRY
902                 __field(enum nl80211_ac, ac)
903                 __field(u16, txop)
904                 __field(u16, cwmin)
905                 __field(u16, cwmax)
906                 __field(u8, aifs)
907         ),
908         TP_fast_assign(
909                 WIPHY_ASSIGN;
910                 NETDEV_ASSIGN;
911                 __entry->ac = params->ac;
912                 __entry->txop = params->txop;
913                 __entry->cwmin = params->cwmin;
914                 __entry->cwmax = params->cwmax;
915                 __entry->aifs = params->aifs;
916         ),
917         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u",
918                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop,
919                   __entry->cwmin, __entry->cwmax, __entry->aifs)
920 );
921
922 TRACE_EVENT(rdev_libertas_set_mesh_channel,
923         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
924                  struct ieee80211_channel *chan),
925         TP_ARGS(wiphy, netdev, chan),
926         TP_STRUCT__entry(
927                 WIPHY_ENTRY
928                 NETDEV_ENTRY
929                 CHAN_ENTRY
930         ),
931         TP_fast_assign(
932                 WIPHY_ASSIGN;
933                 NETDEV_ASSIGN;
934                 CHAN_ASSIGN(chan);
935         ),
936         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT CHAN_PR_FMT, WIPHY_PR_ARG,
937                   NETDEV_PR_ARG, CHAN_PR_ARG)
938 );
939
940 TRACE_EVENT(rdev_set_monitor_channel,
941         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *chan,
942                  enum nl80211_channel_type chan_type),
943         TP_ARGS(wiphy, chan, chan_type),
944         TP_STRUCT__entry(
945                 WIPHY_ENTRY
946                 CHAN_ENTRY
947                 __field(enum nl80211_channel_type, chan_type)
948         ),
949         TP_fast_assign(
950                 WIPHY_ASSIGN;
951                 CHAN_ASSIGN(chan);
952                 __entry->chan_type = chan_type;
953         ),
954         TP_printk(WIPHY_PR_FMT CHAN_PR_FMT ", channel type : %d",
955                   WIPHY_PR_ARG, CHAN_PR_ARG, __entry->chan_type)
956 );
957
958 TRACE_EVENT(rdev_auth,
959         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
960                  struct cfg80211_auth_request *req),
961         TP_ARGS(wiphy, netdev, req),
962         TP_STRUCT__entry(
963                 WIPHY_ENTRY
964                 NETDEV_ENTRY
965                 MAC_ENTRY(bssid)
966                 __field(enum nl80211_auth_type, auth_type)
967         ),
968         TP_fast_assign(
969                 WIPHY_ASSIGN;
970                 NETDEV_ASSIGN;
971                 if (req->bss)
972                         MAC_ASSIGN(bssid, req->bss->bssid);
973                 else
974                         memset(__entry->bssid, 0, ETH_ALEN);
975                 __entry->auth_type = req->auth_type;
976         ),
977         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", auth type: %d, bssid: " MAC_PR_FMT,
978                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type,
979                   MAC_PR_ARG(bssid))
980 );
981
982 TRACE_EVENT(rdev_assoc,
983         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
984                  struct cfg80211_assoc_request *req),
985         TP_ARGS(wiphy, netdev, req),
986         TP_STRUCT__entry(
987                 WIPHY_ENTRY
988                 NETDEV_ENTRY
989                 MAC_ENTRY(bssid)
990                 MAC_ENTRY(prev_bssid)
991                 __field(bool, use_mfp)
992                 __field(u32, flags)
993         ),
994         TP_fast_assign(
995                 WIPHY_ASSIGN;
996                 NETDEV_ASSIGN;
997                 if (req->bss)
998                         MAC_ASSIGN(bssid, req->bss->bssid);
999                 else
1000                         memset(__entry->bssid, 0, ETH_ALEN);
1001                 MAC_ASSIGN(prev_bssid, req->prev_bssid);
1002                 __entry->use_mfp = req->use_mfp;
1003                 __entry->flags = req->flags;
1004         ),
1005         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1006                   ", previous bssid: " MAC_PR_FMT ", use mfp: %s, flags: %u",
1007                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1008                   MAC_PR_ARG(prev_bssid), BOOL_TO_STR(__entry->use_mfp),
1009                   __entry->flags)
1010 );
1011
1012 TRACE_EVENT(rdev_deauth,
1013         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1014                  struct cfg80211_deauth_request *req),
1015         TP_ARGS(wiphy, netdev, req),
1016         TP_STRUCT__entry(
1017                 WIPHY_ENTRY
1018                 NETDEV_ENTRY
1019                 MAC_ENTRY(bssid)
1020                 __field(u16, reason_code)
1021         ),
1022         TP_fast_assign(
1023                 WIPHY_ASSIGN;
1024                 NETDEV_ASSIGN;
1025                 MAC_ASSIGN(bssid, req->bssid);
1026                 __entry->reason_code = req->reason_code;
1027         ),
1028         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", reason: %u",
1029                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1030                   __entry->reason_code)
1031 );
1032
1033 TRACE_EVENT(rdev_disassoc,
1034         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1035                  struct cfg80211_disassoc_request *req),
1036         TP_ARGS(wiphy, netdev, req),
1037         TP_STRUCT__entry(
1038                 WIPHY_ENTRY
1039                 NETDEV_ENTRY
1040                 MAC_ENTRY(bssid)
1041                 __field(u16, reason_code)
1042                 __field(bool, local_state_change)
1043         ),
1044         TP_fast_assign(
1045                 WIPHY_ASSIGN;
1046                 NETDEV_ASSIGN;
1047                 if (req->bss)
1048                         MAC_ASSIGN(bssid, req->bss->bssid);
1049                 else
1050                         memset(__entry->bssid, 0, ETH_ALEN);
1051                 __entry->reason_code = req->reason_code;
1052                 __entry->local_state_change = req->local_state_change;
1053         ),
1054         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1055                   ", reason: %u, local state change: %s",
1056                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1057                   __entry->reason_code,
1058                   BOOL_TO_STR(__entry->local_state_change))
1059 );
1060
1061 TRACE_EVENT(rdev_mgmt_tx_cancel_wait,
1062         TP_PROTO(struct wiphy *wiphy,
1063                  struct wireless_dev *wdev, u64 cookie),
1064         TP_ARGS(wiphy, wdev, cookie),
1065         TP_STRUCT__entry(
1066                 WIPHY_ENTRY
1067                 WDEV_ENTRY
1068                 __field(u64, cookie)
1069         ),
1070         TP_fast_assign(
1071                 WIPHY_ASSIGN;
1072                 WDEV_ASSIGN;
1073                 __entry->cookie = cookie;
1074         ),
1075         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT ", cookie: %llu ",
1076                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
1077 );
1078
1079 TRACE_EVENT(rdev_set_power_mgmt,
1080         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1081                  bool enabled, int timeout),
1082         TP_ARGS(wiphy, netdev, enabled, timeout),
1083         TP_STRUCT__entry(
1084                 WIPHY_ENTRY
1085                 NETDEV_ENTRY
1086                 __field(bool, enabled)
1087                 __field(int, timeout)
1088         ),
1089         TP_fast_assign(
1090                 WIPHY_ASSIGN;
1091                 NETDEV_ASSIGN;
1092                 __entry->enabled = enabled;
1093                 __entry->timeout = timeout;
1094         ),
1095         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", %senabled, timeout: %d ",
1096                   WIPHY_PR_ARG, NETDEV_PR_ARG,
1097                   __entry->enabled ? "" : "not ", __entry->timeout)
1098 );
1099
1100 TRACE_EVENT(rdev_connect,
1101         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1102                  struct cfg80211_connect_params *sme),
1103         TP_ARGS(wiphy, netdev, sme),
1104         TP_STRUCT__entry(
1105                 WIPHY_ENTRY
1106                 NETDEV_ENTRY
1107                 MAC_ENTRY(bssid)
1108                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1109                 __field(enum nl80211_auth_type, auth_type)
1110                 __field(bool, privacy)
1111                 __field(u32, wpa_versions)
1112                 __field(u32, flags)
1113         ),
1114         TP_fast_assign(
1115                 WIPHY_ASSIGN;
1116                 NETDEV_ASSIGN;
1117                 MAC_ASSIGN(bssid, sme->bssid);
1118                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1119                 memcpy(__entry->ssid, sme->ssid, sme->ssid_len);
1120                 __entry->auth_type = sme->auth_type;
1121                 __entry->privacy = sme->privacy;
1122                 __entry->wpa_versions = sme->crypto.wpa_versions;
1123                 __entry->flags = sme->flags;
1124         ),
1125         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1126                   ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, "
1127                   "flags: %u",
1128                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid,
1129                   __entry->auth_type, BOOL_TO_STR(__entry->privacy),
1130                   __entry->wpa_versions, __entry->flags)
1131 );
1132
1133 TRACE_EVENT(rdev_set_cqm_rssi_config,
1134         TP_PROTO(struct wiphy *wiphy,
1135                  struct net_device *netdev, s32 rssi_thold,
1136                  u32 rssi_hyst),
1137         TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst),
1138         TP_STRUCT__entry(
1139                 WIPHY_ENTRY
1140                 NETDEV_ENTRY
1141                 __field(s32, rssi_thold)
1142                 __field(u32, rssi_hyst)
1143         ),
1144         TP_fast_assign(
1145                 WIPHY_ASSIGN;
1146                 NETDEV_ASSIGN;
1147                 __entry->rssi_thold = rssi_thold;
1148                 __entry->rssi_hyst = rssi_hyst;
1149         ),
1150         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT
1151                   ", rssi_thold: %d, rssi_hyst: %u ",
1152                   WIPHY_PR_ARG, NETDEV_PR_ARG,
1153                  __entry->rssi_thold, __entry->rssi_hyst)
1154 );
1155
1156 TRACE_EVENT(rdev_set_cqm_txe_config,
1157         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate,
1158                  u32 pkts, u32 intvl),
1159         TP_ARGS(wiphy, netdev, rate, pkts, intvl),
1160         TP_STRUCT__entry(
1161                 WIPHY_ENTRY
1162                 NETDEV_ENTRY
1163                 __field(u32, rate)
1164                 __field(u32, pkts)
1165                 __field(u32, intvl)
1166         ),
1167         TP_fast_assign(
1168                 WIPHY_ASSIGN;
1169                 NETDEV_ASSIGN;
1170                 __entry->rate = rate;
1171                 __entry->pkts = pkts;
1172                 __entry->intvl = intvl;
1173         ),
1174         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u",
1175                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts,
1176                   __entry->intvl)
1177 );
1178
1179 TRACE_EVENT(rdev_disconnect,
1180         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1181                  u16 reason_code),
1182         TP_ARGS(wiphy, netdev, reason_code),
1183         TP_STRUCT__entry(
1184                 WIPHY_ENTRY
1185                 NETDEV_ENTRY
1186                 __field(u16, reason_code)
1187         ),
1188         TP_fast_assign(
1189                 WIPHY_ASSIGN;
1190                 NETDEV_ASSIGN;
1191                 __entry->reason_code = reason_code;
1192         ),
1193         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG,
1194                   NETDEV_PR_ARG, __entry->reason_code)
1195 );
1196
1197 TRACE_EVENT(rdev_join_ibss,
1198         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1199                  struct cfg80211_ibss_params *params),
1200         TP_ARGS(wiphy, netdev, params),
1201         TP_STRUCT__entry(
1202                 WIPHY_ENTRY
1203                 NETDEV_ENTRY
1204                 MAC_ENTRY(bssid)
1205                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1206         ),
1207         TP_fast_assign(
1208                 WIPHY_ASSIGN;
1209                 NETDEV_ASSIGN;
1210                 MAC_ASSIGN(bssid, params->bssid);
1211                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1212                 memcpy(__entry->ssid, params->ssid, params->ssid_len);
1213         ),
1214         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", ssid: %s",
1215                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid)
1216 );
1217
1218 TRACE_EVENT(rdev_set_wiphy_params,
1219         TP_PROTO(struct wiphy *wiphy, u32 changed),
1220         TP_ARGS(wiphy, changed),
1221         TP_STRUCT__entry(
1222                 WIPHY_ENTRY
1223                 __field(u32, changed)
1224         ),
1225         TP_fast_assign(
1226                 WIPHY_ASSIGN;
1227                 __entry->changed = changed;
1228         ),
1229         TP_printk(WIPHY_PR_FMT ", changed: %u",
1230                   WIPHY_PR_ARG, __entry->changed)
1231 );
1232
1233 TRACE_EVENT(rdev_set_tx_power,
1234         TP_PROTO(struct wiphy *wiphy, enum nl80211_tx_power_setting type,
1235                  int mbm),
1236         TP_ARGS(wiphy, type, mbm),
1237         TP_STRUCT__entry(
1238                 WIPHY_ENTRY
1239                 __field(enum nl80211_tx_power_setting, type)
1240                 __field(int, mbm)
1241         ),
1242         TP_fast_assign(
1243                 WIPHY_ASSIGN;
1244                 __entry->type = type;
1245                 __entry->mbm = mbm;
1246         ),
1247         TP_printk(WIPHY_PR_FMT ", type: %d, mbm: %d",
1248                   WIPHY_PR_ARG, __entry->type, __entry->mbm)
1249 );
1250
1251 TRACE_EVENT(rdev_return_int_int,
1252         TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill),
1253         TP_ARGS(wiphy, func_ret, func_fill),
1254         TP_STRUCT__entry(
1255                 WIPHY_ENTRY
1256                 __field(int, func_ret)
1257                 __field(int, func_fill)
1258         ),
1259         TP_fast_assign(
1260                 WIPHY_ASSIGN;
1261                 __entry->func_ret = func_ret;
1262                 __entry->func_fill = func_fill;
1263         ),
1264         TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d",
1265                   WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill)
1266 );
1267
1268 #ifdef CONFIG_NL80211_TESTMODE
1269 TRACE_EVENT(rdev_testmode_cmd,
1270         TP_PROTO(struct wiphy *wiphy),
1271         TP_ARGS(wiphy),
1272         TP_STRUCT__entry(
1273                 WIPHY_ENTRY
1274         ),
1275         TP_fast_assign(
1276                 WIPHY_ASSIGN;
1277         ),
1278         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
1279 );
1280
1281 TRACE_EVENT(rdev_testmode_dump,
1282         TP_PROTO(struct wiphy *wiphy),
1283         TP_ARGS(wiphy),
1284         TP_STRUCT__entry(
1285                 WIPHY_ENTRY
1286         ),
1287         TP_fast_assign(
1288                 WIPHY_ASSIGN;
1289         ),
1290         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
1291 );
1292 #endif /* CONFIG_NL80211_TESTMODE */
1293
1294 TRACE_EVENT(rdev_set_bitrate_mask,
1295         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1296                  const u8 *peer, const struct cfg80211_bitrate_mask *mask),
1297         TP_ARGS(wiphy, netdev, peer, mask),
1298         TP_STRUCT__entry(
1299                 WIPHY_ENTRY
1300                 NETDEV_ENTRY
1301                 MAC_ENTRY(peer)
1302         ),
1303         TP_fast_assign(
1304                 WIPHY_ASSIGN;
1305                 NETDEV_ASSIGN;
1306                 MAC_ASSIGN(peer, peer);
1307         ),
1308         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", peer: " MAC_PR_FMT,
1309                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
1310 );
1311
1312 TRACE_EVENT(rdev_mgmt_frame_register,
1313         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1314                  u16 frame_type, bool reg),
1315         TP_ARGS(wiphy, wdev, frame_type, reg),
1316         TP_STRUCT__entry(
1317                 WIPHY_ENTRY
1318                 WDEV_ENTRY
1319                 __field(u16, frame_type)
1320                 __field(bool, reg)
1321         ),
1322         TP_fast_assign(
1323                 WIPHY_ASSIGN;
1324                 WDEV_ASSIGN;
1325                 __entry->frame_type = frame_type;
1326                 __entry->reg = reg;
1327         ),
1328         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT ", frame_type: %u, reg: %s ",
1329                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->frame_type,
1330                   __entry->reg ? "true" : "false")
1331 );
1332
1333 TRACE_EVENT(rdev_return_int_tx_rx,
1334         TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx),
1335         TP_ARGS(wiphy, ret, tx, rx),
1336         TP_STRUCT__entry(
1337                 WIPHY_ENTRY
1338                 __field(int, ret)
1339                 __field(u32, tx)
1340                 __field(u32, rx)
1341         ),
1342         TP_fast_assign(
1343                 WIPHY_ASSIGN;
1344                 __entry->ret = ret;
1345                 __entry->tx = tx;
1346                 __entry->rx = rx;
1347         ),
1348         TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u",
1349                   WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx)
1350 );
1351
1352 TRACE_EVENT(rdev_return_void_tx_rx,
1353         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max,
1354                  u32 rx, u32 rx_max),
1355         TP_ARGS(wiphy, tx, tx_max, rx, rx_max),
1356         TP_STRUCT__entry(
1357                 WIPHY_ENTRY
1358                 __field(u32, tx)
1359                 __field(u32, tx_max)
1360                 __field(u32, rx)
1361                 __field(u32, rx_max)
1362         ),
1363         TP_fast_assign(
1364                 WIPHY_ASSIGN;
1365                 __entry->tx = tx;
1366                 __entry->tx_max = tx_max;
1367                 __entry->rx = rx;
1368                 __entry->rx_max = rx_max;
1369         ),
1370         TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ",
1371                   WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx,
1372                   __entry->rx_max)
1373 );
1374
1375 DECLARE_EVENT_CLASS(tx_rx_evt,
1376         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
1377         TP_ARGS(wiphy, rx, tx),
1378         TP_STRUCT__entry(
1379                 WIPHY_ENTRY
1380                 __field(u32, tx)
1381                 __field(u32, rx)
1382         ),
1383         TP_fast_assign(
1384                 WIPHY_ASSIGN;
1385                 __entry->tx = tx;
1386                 __entry->rx = rx;
1387         ),
1388         TP_printk(WIPHY_PR_FMT ", tx: %u, rx: %u ",
1389                   WIPHY_PR_ARG, __entry->tx, __entry->rx)
1390 );
1391
1392 DEFINE_EVENT(tx_rx_evt, rdev_set_ringparam,
1393         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
1394         TP_ARGS(wiphy, rx, tx)
1395 );
1396
1397 DEFINE_EVENT(tx_rx_evt, rdev_set_antenna,
1398         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
1399         TP_ARGS(wiphy, rx, tx)
1400 );
1401
1402 TRACE_EVENT(rdev_sched_scan_start,
1403         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1404                  struct cfg80211_sched_scan_request *request),
1405         TP_ARGS(wiphy, netdev, request),
1406         TP_STRUCT__entry(
1407                 WIPHY_ENTRY
1408                 NETDEV_ENTRY
1409         ),
1410         TP_fast_assign(
1411                 WIPHY_ASSIGN;
1412                 NETDEV_ASSIGN;
1413         ),
1414         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT,
1415                   WIPHY_PR_ARG, NETDEV_PR_ARG)
1416 );
1417
1418 TRACE_EVENT(rdev_tdls_mgmt,
1419         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1420                  u8 *peer, u8 action_code, u8 dialog_token,
1421                  u16 status_code, const u8 *buf, size_t len),
1422         TP_ARGS(wiphy, netdev, peer, action_code, dialog_token, status_code,
1423                 buf, len),
1424         TP_STRUCT__entry(
1425                 WIPHY_ENTRY
1426                 NETDEV_ENTRY
1427                 MAC_ENTRY(peer)
1428                 __field(u8, action_code)
1429                 __field(u8, dialog_token)
1430                 __field(u16, status_code)
1431                 __dynamic_array(u8, buf, len)
1432         ),
1433         TP_fast_assign(
1434                 WIPHY_ASSIGN;
1435                 NETDEV_ASSIGN;
1436                 MAC_ASSIGN(peer, peer);
1437                 __entry->action_code = action_code;
1438                 __entry->dialog_token = dialog_token;
1439                 __entry->status_code = status_code;
1440                 memcpy(__get_dynamic_array(buf), buf, len);
1441         ),
1442         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT MAC_PR_FMT ", action_code: %u, "
1443                   "dialog_token: %u, status_code: %u, buf: %#.2x ",
1444                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
1445                   __entry->action_code, __entry->dialog_token,
1446                   __entry->status_code, ((u8 *)__get_dynamic_array(buf))[0])
1447 );
1448
1449 TRACE_EVENT(rdev_dump_survey,
1450         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx),
1451         TP_ARGS(wiphy, netdev, idx),
1452         TP_STRUCT__entry(
1453                 WIPHY_ENTRY
1454                 NETDEV_ENTRY
1455                 __field(int, idx)
1456         ),
1457         TP_fast_assign(
1458                 WIPHY_ASSIGN;
1459                 NETDEV_ASSIGN;
1460                 __entry->idx = idx;
1461         ),
1462         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", index: %d",
1463                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx)
1464 );
1465
1466 TRACE_EVENT(rdev_return_int_survey_info,
1467         TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info),
1468         TP_ARGS(wiphy, ret, info),
1469         TP_STRUCT__entry(
1470                 WIPHY_ENTRY
1471                 CHAN_ENTRY
1472                 __field(int, ret)
1473                 __field(u64, channel_time)
1474                 __field(u64, channel_time_busy)
1475                 __field(u64, channel_time_ext_busy)
1476                 __field(u64, channel_time_rx)
1477                 __field(u64, channel_time_tx)
1478                 __field(u32, filled)
1479                 __field(s8, noise)
1480         ),
1481         TP_fast_assign(
1482                 WIPHY_ASSIGN;
1483                 CHAN_ASSIGN(info->channel);
1484                 __entry->ret = ret;
1485                 __entry->channel_time = info->channel_time;
1486                 __entry->channel_time_busy = info->channel_time_busy;
1487                 __entry->channel_time_ext_busy = info->channel_time_ext_busy;
1488                 __entry->channel_time_rx = info->channel_time_rx;
1489                 __entry->channel_time_tx = info->channel_time_tx;
1490                 __entry->filled = info->filled;
1491                 __entry->noise = info->noise;
1492         ),
1493         TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT
1494                   ", channel time: %llu, channel time busy: %llu, "
1495                   "channel time extension busy: %llu, channel time rx: %llu, "
1496                   "channel time tx: %llu, filled: %u, noise: %d",
1497                   WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG,
1498                   __entry->channel_time, __entry->channel_time_busy,
1499                   __entry->channel_time_ext_busy, __entry->channel_time_rx,
1500                   __entry->channel_time_tx, __entry->filled, __entry->noise)
1501 );
1502
1503 TRACE_EVENT(rdev_tdls_oper,
1504         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1505                  u8 *peer, enum nl80211_tdls_operation oper),
1506         TP_ARGS(wiphy, netdev, peer, oper),
1507         TP_STRUCT__entry(
1508                 WIPHY_ENTRY
1509                 NETDEV_ENTRY
1510                 MAC_ENTRY(peer)
1511                 __field(enum nl80211_tdls_operation, oper)
1512         ),
1513         TP_fast_assign(
1514                 WIPHY_ASSIGN;
1515                 NETDEV_ASSIGN;
1516                 MAC_ASSIGN(peer, peer);
1517                 __entry->oper = oper;
1518         ),
1519         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT MAC_PR_FMT ", oper: %d",
1520                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper)
1521 );
1522
1523 DECLARE_EVENT_CLASS(rdev_pmksa,
1524         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1525                  struct cfg80211_pmksa *pmksa),
1526         TP_ARGS(wiphy, netdev, pmksa),
1527         TP_STRUCT__entry(
1528                 WIPHY_ENTRY
1529                 NETDEV_ENTRY
1530                 MAC_ENTRY(bssid)
1531         ),
1532         TP_fast_assign(
1533                 WIPHY_ASSIGN;
1534                 NETDEV_ASSIGN;
1535                 MAC_ASSIGN(bssid, pmksa->bssid);
1536         ),
1537         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", bssid: " MAC_PR_FMT,
1538                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid))
1539 );
1540
1541 TRACE_EVENT(rdev_probe_client,
1542         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1543                  const u8 *peer),
1544         TP_ARGS(wiphy, netdev, peer),
1545         TP_STRUCT__entry(
1546                 WIPHY_ENTRY
1547                 NETDEV_ENTRY
1548                 MAC_ENTRY(peer)
1549         ),
1550         TP_fast_assign(
1551                 WIPHY_ASSIGN;
1552                 NETDEV_ASSIGN;
1553                 MAC_ASSIGN(peer, peer);
1554         ),
1555         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT MAC_PR_FMT,
1556                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
1557 );
1558
1559 DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa,
1560         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1561                  struct cfg80211_pmksa *pmksa),
1562         TP_ARGS(wiphy, netdev, pmksa)
1563 );
1564
1565 DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa,
1566         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1567                  struct cfg80211_pmksa *pmksa),
1568         TP_ARGS(wiphy, netdev, pmksa)
1569 );
1570
1571 TRACE_EVENT(rdev_remain_on_channel,
1572         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1573                  struct ieee80211_channel *chan,
1574                  enum nl80211_channel_type channel_type, unsigned int duration),
1575         TP_ARGS(wiphy, wdev, chan, channel_type, duration),
1576         TP_STRUCT__entry(
1577                 WIPHY_ENTRY
1578                 WDEV_ENTRY
1579                 CHAN_ENTRY
1580                 __field(enum nl80211_channel_type, channel_type)
1581                 __field(unsigned int, duration)
1582         ),
1583         TP_fast_assign(
1584                 WIPHY_ASSIGN;
1585                 WDEV_ASSIGN;
1586                 CHAN_ASSIGN(chan);
1587                 __entry->channel_type = channel_type;
1588                 __entry->duration = duration;
1589         ),
1590         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT CHAN_PR_FMT ", channel type: %d, duration: %u",
1591                   WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->channel_type,
1592                   __entry->duration)
1593 );
1594
1595 TRACE_EVENT(rdev_return_int_cookie,
1596         TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie),
1597         TP_ARGS(wiphy, ret, cookie),
1598         TP_STRUCT__entry(
1599                 WIPHY_ENTRY
1600                 __field(int, ret)
1601                 __field(u64, cookie)
1602         ),
1603         TP_fast_assign(
1604                 WIPHY_ASSIGN;
1605                 __entry->ret = ret;
1606                 __entry->cookie = cookie;
1607         ),
1608         TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu",
1609                   WIPHY_PR_ARG, __entry->ret, __entry->cookie)
1610 );
1611
1612 TRACE_EVENT(rdev_cancel_remain_on_channel,
1613         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
1614         TP_ARGS(wiphy, wdev, cookie),
1615         TP_STRUCT__entry(
1616                 WIPHY_ENTRY
1617                 WDEV_ENTRY
1618                 __field(u64, cookie)
1619         ),
1620         TP_fast_assign(
1621                 WIPHY_ASSIGN;
1622                 WDEV_ASSIGN;
1623                 __entry->cookie = cookie;
1624         ),
1625         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT ", cookie: %llu",
1626                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
1627 );
1628
1629 TRACE_EVENT(rdev_mgmt_tx,
1630         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1631                  struct ieee80211_channel *chan, bool offchan,
1632                  enum nl80211_channel_type channel_type,
1633                  bool channel_type_valid, unsigned int wait, bool no_cck,
1634                  bool dont_wait_for_ack),
1635         TP_ARGS(wiphy, wdev, chan, offchan, channel_type, channel_type_valid,
1636                 wait, no_cck, dont_wait_for_ack),
1637         TP_STRUCT__entry(
1638                 WIPHY_ENTRY
1639                 WDEV_ENTRY
1640                 CHAN_ENTRY
1641                 __field(bool, offchan)
1642                 __field(enum nl80211_channel_type, channel_type)
1643                 __field(bool, channel_type_valid)
1644                 __field(unsigned int, wait)
1645                 __field(bool, no_cck)
1646                 __field(bool, dont_wait_for_ack)
1647         ),
1648         TP_fast_assign(
1649                 WIPHY_ASSIGN;
1650                 WDEV_ASSIGN;
1651                 CHAN_ASSIGN(chan);
1652                 __entry->offchan = offchan;
1653                 __entry->channel_type = channel_type;
1654                 __entry->channel_type_valid = channel_type_valid;
1655                 __entry->wait = wait;
1656                 __entry->no_cck = no_cck;
1657                 __entry->dont_wait_for_ack = dont_wait_for_ack;
1658         ),
1659         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT CHAN_PR_FMT ", offchan: %s, "
1660                   "channel type: %d, channel type valid: %s, wait: %u, "
1661                   "no cck: %s, dont wait for ack: %s",
1662                   WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG,
1663                   BOOL_TO_STR(__entry->offchan), __entry->channel_type,
1664                   BOOL_TO_STR(__entry->channel_type_valid), __entry->wait,
1665                   BOOL_TO_STR(__entry->no_cck),
1666                   BOOL_TO_STR(__entry->dont_wait_for_ack))
1667 );
1668
1669 TRACE_EVENT(rdev_set_noack_map,
1670         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1671                  u16 noack_map),
1672         TP_ARGS(wiphy, netdev, noack_map),
1673         TP_STRUCT__entry(
1674                 WIPHY_ENTRY
1675                 NETDEV_ENTRY
1676                 __field(u16, noack_map)
1677         ),
1678         TP_fast_assign(
1679                 WIPHY_ASSIGN;
1680                 NETDEV_ASSIGN;
1681                 __entry->noack_map = noack_map;
1682         ),
1683         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", noack_map: %u",
1684                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map)
1685 );
1686
1687 TRACE_EVENT(rdev_get_et_sset_count,
1688         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int sset),
1689         TP_ARGS(wiphy, netdev, sset),
1690         TP_STRUCT__entry(
1691                 WIPHY_ENTRY
1692                 NETDEV_ENTRY
1693                 __field(int, sset)
1694         ),
1695         TP_fast_assign(
1696                 WIPHY_ASSIGN;
1697                 NETDEV_ASSIGN;
1698                 __entry->sset = sset;
1699         ),
1700         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", sset: %d",
1701                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sset)
1702 );
1703
1704 TRACE_EVENT(rdev_get_et_strings,
1705         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 sset),
1706         TP_ARGS(wiphy, netdev, sset),
1707         TP_STRUCT__entry(
1708                 WIPHY_ENTRY
1709                 NETDEV_ENTRY
1710                 __field(u32, sset)
1711         ),
1712         TP_fast_assign(
1713                 WIPHY_ASSIGN;
1714                 NETDEV_ASSIGN;
1715                 __entry->sset = sset;
1716         ),
1717         TP_printk(WIPHY_PR_FMT NETDEV_PR_FMT ", sset: %u",
1718                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sset)
1719 );
1720
1721 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel,
1722         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1723         TP_ARGS(wiphy, wdev)
1724 );
1725
1726 TRACE_EVENT(rdev_return_channel,
1727         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *chan,
1728                  enum nl80211_channel_type type),
1729         TP_ARGS(wiphy, chan, type),
1730         TP_STRUCT__entry(
1731                 WIPHY_ENTRY
1732                 CHAN_ENTRY
1733                 __field(enum nl80211_channel_type, type)
1734         ),
1735         TP_fast_assign(
1736                 WIPHY_ASSIGN;
1737                 CHAN_ASSIGN(chan);
1738                 __entry->type = type;
1739         ),
1740         TP_printk(WIPHY_PR_FMT CHAN_PR_FMT ", channel type: %d",
1741                   WIPHY_PR_ARG, CHAN_PR_ARG, __entry->type)
1742 );
1743
1744 DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device,
1745         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1746         TP_ARGS(wiphy, wdev)
1747 );
1748
1749 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device,
1750         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1751         TP_ARGS(wiphy, wdev)
1752 );
1753
1754 /*************************************************************
1755  *           cfg80211 exported functions traces              *
1756  *************************************************************/
1757
1758 TRACE_EVENT(cfg80211_return_bool,
1759         TP_PROTO(bool ret),
1760         TP_ARGS(ret),
1761         TP_STRUCT__entry(
1762                 __field(bool, ret)
1763         ),
1764         TP_fast_assign(
1765                 __entry->ret = ret;
1766         ),
1767         TP_printk("returned %s", BOOL_TO_STR(__entry->ret))
1768 );
1769
1770 DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt,
1771         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
1772         TP_ARGS(netdev, macaddr),
1773         TP_STRUCT__entry(
1774                 NETDEV_ENTRY
1775                 MAC_ENTRY(macaddr)
1776         ),
1777         TP_fast_assign(
1778                 NETDEV_ASSIGN;
1779                 MAC_ASSIGN(macaddr, macaddr);
1780         ),
1781         TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
1782                   NETDEV_PR_ARG, MAC_PR_ARG(macaddr))
1783 );
1784
1785 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate,
1786         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
1787         TP_ARGS(netdev, macaddr)
1788 );
1789
1790 DECLARE_EVENT_CLASS(netdev_evt_only,
1791         TP_PROTO(struct net_device *netdev),
1792         TP_ARGS(netdev),
1793         TP_STRUCT__entry(
1794                 NETDEV_ENTRY
1795         ),
1796         TP_fast_assign(
1797                 NETDEV_ASSIGN;
1798         ),
1799         TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG)
1800 );
1801
1802 DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth,
1803         TP_PROTO(struct net_device *netdev),
1804         TP_ARGS(netdev)
1805 );
1806
1807 TRACE_EVENT(cfg80211_send_rx_assoc,
1808         TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss),
1809         TP_ARGS(netdev, bss),
1810         TP_STRUCT__entry(
1811                 NETDEV_ENTRY
1812                 MAC_ENTRY(bssid)
1813                 CHAN_ENTRY
1814         ),
1815         TP_fast_assign(
1816                 NETDEV_ASSIGN;
1817                 MAC_ASSIGN(bssid, bss->bssid);
1818                 CHAN_ASSIGN(bss->channel);
1819         ),
1820         TP_printk(NETDEV_PR_FMT MAC_PR_FMT CHAN_PR_FMT,
1821                   NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
1822 );
1823
1824 DEFINE_EVENT(netdev_evt_only, __cfg80211_send_deauth,
1825         TP_PROTO(struct net_device *netdev),
1826         TP_ARGS(netdev)
1827 );
1828
1829 DEFINE_EVENT(netdev_evt_only, __cfg80211_send_disassoc,
1830         TP_PROTO(struct net_device *netdev),
1831         TP_ARGS(netdev)
1832 );
1833
1834 DEFINE_EVENT(netdev_evt_only, cfg80211_send_unprot_deauth,
1835         TP_PROTO(struct net_device *netdev),
1836         TP_ARGS(netdev)
1837 );
1838
1839 DEFINE_EVENT(netdev_evt_only, cfg80211_send_unprot_disassoc,
1840         TP_PROTO(struct net_device *netdev),
1841         TP_ARGS(netdev)
1842 );
1843
1844 DECLARE_EVENT_CLASS(netdev_mac_evt,
1845         TP_PROTO(struct net_device *netdev, const u8 *mac),
1846         TP_ARGS(netdev, mac),
1847         TP_STRUCT__entry(
1848                 NETDEV_ENTRY
1849                 MAC_ENTRY(mac)
1850         ),
1851         TP_fast_assign(
1852                 NETDEV_ASSIGN;
1853                 MAC_ASSIGN(mac, mac)
1854         ),
1855         TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
1856                   NETDEV_PR_ARG, MAC_PR_ARG(mac))
1857 );
1858
1859 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout,
1860         TP_PROTO(struct net_device *netdev, const u8 *mac),
1861         TP_ARGS(netdev, mac)
1862 );
1863
1864 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout,
1865         TP_PROTO(struct net_device *netdev, const u8 *mac),
1866         TP_ARGS(netdev, mac)
1867 );
1868
1869 TRACE_EVENT(cfg80211_michael_mic_failure,
1870         TP_PROTO(struct net_device *netdev, const u8 *addr,
1871                  enum nl80211_key_type key_type, int key_id, const u8 *tsc),
1872         TP_ARGS(netdev, addr, key_type, key_id, tsc),
1873         TP_STRUCT__entry(
1874                 NETDEV_ENTRY
1875                 MAC_ENTRY(addr)
1876                 __field(enum nl80211_key_type, key_type)
1877                 __field(int, key_id)
1878                 __array(u8, tsc, 6)
1879         ),
1880         TP_fast_assign(
1881                 NETDEV_ASSIGN;
1882                 MAC_ASSIGN(addr, addr);
1883                 __entry->key_type = key_type;
1884                 __entry->key_id = key_id;
1885                 memcpy(__entry->tsc, tsc, 6);
1886         ),
1887         TP_printk(NETDEV_PR_FMT MAC_PR_FMT ", key type: %d, key id: %d, tsc: %pm",
1888                   NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->key_type,
1889                   __entry->key_id, __entry->tsc)
1890 );
1891
1892 TRACE_EVENT(cfg80211_ready_on_channel,
1893         TP_PROTO(struct wireless_dev *wdev, u64 cookie,
1894                  struct ieee80211_channel *chan,
1895                  enum nl80211_channel_type channel_type, unsigned int duration),
1896         TP_ARGS(wdev, cookie, chan, channel_type, duration),
1897         TP_STRUCT__entry(
1898                 WDEV_ENTRY
1899                 __field(u64, cookie)
1900                 CHAN_ENTRY
1901                 __field(enum nl80211_channel_type, channel_type)
1902                 __field(unsigned int, duration)
1903         ),
1904         TP_fast_assign(
1905                 WDEV_ASSIGN;
1906                 __entry->cookie = cookie;
1907                 CHAN_ASSIGN(chan);
1908                 __entry->channel_type = channel_type;
1909                 __entry->duration = duration;
1910         ),
1911         TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", channel type: %d, duration: %u",
1912                   WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG,
1913                   __entry->channel_type, __entry->duration)
1914 );
1915
1916 TRACE_EVENT(cfg80211_ready_on_channel_expired,
1917         TP_PROTO(struct wireless_dev *wdev, u64 cookie,
1918                  struct ieee80211_channel *chan,
1919                  enum nl80211_channel_type channel_type),
1920         TP_ARGS(wdev, cookie, chan, channel_type),
1921         TP_STRUCT__entry(
1922                 WDEV_ENTRY
1923                 __field(u64, cookie)
1924                 CHAN_ENTRY
1925                 __field(enum nl80211_channel_type, channel_type)
1926         ),
1927         TP_fast_assign(
1928                 WDEV_ASSIGN;
1929                 __entry->cookie = cookie;
1930                 CHAN_ASSIGN(chan);
1931                 __entry->channel_type = channel_type;
1932         ),
1933         TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", channel type: %d",
1934                   WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG,
1935                   __entry->channel_type)
1936 );
1937
1938 TRACE_EVENT(cfg80211_new_sta,
1939         TP_PROTO(struct net_device *netdev, const u8 *mac_addr,
1940                  struct station_info *sinfo),
1941         TP_ARGS(netdev, mac_addr, sinfo),
1942         TP_STRUCT__entry(
1943                 NETDEV_ENTRY
1944                 MAC_ENTRY(mac_addr)
1945                 SINFO_ENTRY
1946         ),
1947         TP_fast_assign(
1948                 NETDEV_ASSIGN;
1949                 MAC_ASSIGN(mac_addr, mac_addr);
1950                 SINFO_ASSIGN;
1951         ),
1952         TP_printk(NETDEV_PR_FMT MAC_PR_FMT,
1953                   NETDEV_PR_ARG, MAC_PR_ARG(mac_addr))
1954 );
1955
1956 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta,
1957         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
1958         TP_ARGS(netdev, macaddr)
1959 );
1960
1961 TRACE_EVENT(cfg80211_rx_mgmt,
1962         TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm),
1963         TP_ARGS(wdev, freq, sig_mbm),
1964         TP_STRUCT__entry(
1965                 WDEV_ENTRY
1966                 __field(int, freq)
1967                 __field(int, sig_mbm)
1968         ),
1969         TP_fast_assign(
1970                 WDEV_ASSIGN;
1971                 __entry->freq = freq;
1972                 __entry->sig_mbm = sig_mbm;
1973         ),
1974         TP_printk(WDEV_PR_FMT ", freq: %d, sig mbm: %d",
1975                   WDEV_PR_ARG, __entry->freq, __entry->sig_mbm)
1976 );
1977
1978 TRACE_EVENT(cfg80211_mgmt_tx_status,
1979         TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack),
1980         TP_ARGS(wdev, cookie, ack),
1981         TP_STRUCT__entry(
1982                 WDEV_ENTRY
1983                 __field(u64, cookie)
1984                 __field(bool, ack)
1985         ),
1986         TP_fast_assign(
1987                 WDEV_ASSIGN;
1988                 __entry->cookie = cookie;
1989                 __entry->ack = ack;
1990         ),
1991         TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s",
1992                   WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack))
1993 );
1994
1995 TRACE_EVENT(cfg80211_cqm_rssi_notify,
1996         TP_PROTO(struct net_device *netdev,
1997                  enum nl80211_cqm_rssi_threshold_event rssi_event),
1998         TP_ARGS(netdev, rssi_event),
1999         TP_STRUCT__entry(
2000                 NETDEV_ENTRY
2001                 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event)
2002         ),
2003         TP_fast_assign(
2004                 NETDEV_ASSIGN;
2005                 __entry->rssi_event = rssi_event;
2006         ),
2007         TP_printk(NETDEV_PR_FMT ", rssi event: %d",
2008                   NETDEV_PR_ARG, __entry->rssi_event)
2009 );
2010
2011 TRACE_EVENT(cfg80211_can_beacon_sec_chan,
2012         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
2013                  enum nl80211_channel_type channel_type),
2014         TP_ARGS(wiphy, channel, channel_type),
2015         TP_STRUCT__entry(
2016                 WIPHY_ENTRY
2017                 CHAN_ENTRY
2018                 __field(enum nl80211_channel_type, channel_type)
2019         ),
2020         TP_fast_assign(
2021                 WIPHY_ASSIGN;
2022                 CHAN_ASSIGN(channel);
2023                 __entry->channel_type = channel_type;
2024         ),
2025         TP_printk(WIPHY_PR_FMT CHAN_PR_FMT ", channel_type: %d",
2026                   WIPHY_PR_ARG, CHAN_PR_ARG, __entry->channel_type)
2027 );
2028
2029 TRACE_EVENT(cfg80211_ch_switch_notify,
2030         TP_PROTO(struct net_device *netdev, int freq,
2031                  enum nl80211_channel_type type),
2032         TP_ARGS(netdev, freq, type),
2033         TP_STRUCT__entry(
2034                 NETDEV_ENTRY
2035                 __field(int, freq)
2036                 __field(enum nl80211_channel_type, type)
2037         ),
2038         TP_fast_assign(
2039                 NETDEV_ASSIGN;
2040                 __entry->freq = freq;
2041                 __entry->type = type;
2042         ),
2043         TP_printk(NETDEV_PR_FMT ", freq: %d, type: %d", NETDEV_PR_ARG,
2044                   __entry->freq, __entry->type)
2045 );
2046
2047 DECLARE_EVENT_CLASS(cfg80211_rx_evt,
2048         TP_PROTO(struct net_device *netdev, const u8 *addr),
2049         TP_ARGS(netdev, addr),
2050         TP_STRUCT__entry(
2051                 NETDEV_ENTRY
2052                 MAC_ENTRY(addr)
2053         ),
2054         TP_fast_assign(
2055                 NETDEV_ASSIGN;
2056                 MAC_ASSIGN(addr, addr);
2057         ),
2058         TP_printk(NETDEV_PR_FMT MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr))
2059 );
2060
2061 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_ibss_joined,
2062         TP_PROTO(struct net_device *netdev, const u8 *addr),
2063         TP_ARGS(netdev, addr)
2064 );
2065
2066 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame,
2067         TP_PROTO(struct net_device *netdev, const u8 *addr),
2068         TP_ARGS(netdev, addr)
2069 );
2070
2071 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame,
2072         TP_PROTO(struct net_device *netdev, const u8 *addr),
2073         TP_ARGS(netdev, addr)
2074 );
2075
2076 TRACE_EVENT(cfg80211_probe_status,
2077         TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie,
2078                  bool acked),
2079         TP_ARGS(netdev, addr, cookie, acked),
2080         TP_STRUCT__entry(
2081                 NETDEV_ENTRY
2082                 MAC_ENTRY(addr)
2083                 __field(u64, cookie)
2084                 __field(bool, acked)
2085         ),
2086         TP_fast_assign(
2087                 NETDEV_ASSIGN;
2088                 MAC_ASSIGN(addr, addr);
2089                 __entry->cookie = cookie;
2090                 __entry->acked = acked;
2091         ),
2092         TP_printk(NETDEV_PR_FMT MAC_PR_FMT ", cookie: %llu, acked: %s",
2093                   NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie,
2094                   BOOL_TO_STR(__entry->acked))
2095 );
2096
2097 TRACE_EVENT(cfg80211_cqm_pktloss_notify,
2098         TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets),
2099         TP_ARGS(netdev, peer, num_packets),
2100         TP_STRUCT__entry(
2101                 NETDEV_ENTRY
2102                 MAC_ENTRY(peer)
2103                 __field(u32, num_packets)
2104         ),
2105         TP_fast_assign(
2106                 NETDEV_ASSIGN;
2107                 MAC_ASSIGN(peer, peer);
2108                 __entry->num_packets = num_packets;
2109         ),
2110         TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u",
2111                   NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets)
2112 );
2113
2114 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify,
2115         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2116         TP_ARGS(netdev, macaddr)
2117 );
2118
2119 TRACE_EVENT(cfg80211_pmksa_candidate_notify,
2120         TP_PROTO(struct net_device *netdev, int index, const u8 *bssid,
2121                  bool preauth),
2122         TP_ARGS(netdev, index, bssid, preauth),
2123         TP_STRUCT__entry(
2124                 NETDEV_ENTRY
2125                 __field(int, index)
2126                 MAC_ENTRY(bssid)
2127                 __field(bool, preauth)
2128         ),
2129         TP_fast_assign(
2130                 NETDEV_ASSIGN;
2131                 __entry->index = index;
2132                 MAC_ASSIGN(bssid, bssid);
2133                 __entry->preauth = preauth;
2134         ),
2135         TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s",
2136                   NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid),
2137                   BOOL_TO_STR(__entry->preauth))
2138 );
2139
2140 TRACE_EVENT(cfg80211_report_obss_beacon,
2141         TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len,
2142                  int freq, int sig_dbm),
2143         TP_ARGS(wiphy, frame, len, freq, sig_dbm),
2144         TP_STRUCT__entry(
2145                 WIPHY_ENTRY
2146                 __field(int, freq)
2147                 __field(int, sig_dbm)
2148         ),
2149         TP_fast_assign(
2150                 WIPHY_ASSIGN;
2151                 __entry->freq = freq;
2152                 __entry->sig_dbm = sig_dbm;
2153         ),
2154         TP_printk(WIPHY_PR_FMT ", freq: %d, sig_dbm: %d",
2155                   WIPHY_PR_ARG, __entry->freq, __entry->sig_dbm)
2156 );
2157
2158 TRACE_EVENT(cfg80211_scan_done,
2159         TP_PROTO(struct cfg80211_scan_request *request, bool aborted),
2160         TP_ARGS(request, aborted),
2161         TP_STRUCT__entry(
2162                 __field(u32, n_channels)
2163                 __dynamic_array(u8, ie, request ? request->ie_len : 0)
2164                 __array(u32, rates, IEEE80211_NUM_BANDS)
2165                 __field(u32, wdev_id)
2166                 MAC_ENTRY(wiphy_mac)
2167                 __field(bool, no_cck)
2168                 __field(bool, aborted)
2169         ),
2170         TP_fast_assign(
2171                 if (request) {
2172                         memcpy(__get_dynamic_array(ie), request->ie,
2173                                request->ie_len);
2174                         memcpy(__entry->rates, request->rates,
2175                                IEEE80211_NUM_BANDS);
2176                         __entry->wdev_id = request->wdev ?
2177                                         request->wdev->identifier : 0;
2178                         if (request->wiphy)
2179                                 MAC_ASSIGN(wiphy_mac,
2180                                            request->wiphy->perm_addr);
2181                         __entry->no_cck = request->no_cck;
2182                 }
2183                 __entry->aborted = aborted;
2184         ),
2185         TP_printk("aborted: %s", BOOL_TO_STR(__entry->aborted))
2186 );
2187
2188 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_results,
2189         TP_PROTO(struct wiphy *wiphy),
2190         TP_ARGS(wiphy)
2191 );
2192
2193 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_stopped,
2194         TP_PROTO(struct wiphy *wiphy),
2195         TP_ARGS(wiphy)
2196 );
2197
2198 TRACE_EVENT(cfg80211_get_bss,
2199         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
2200                  const u8 *bssid, const u8 *ssid, size_t ssid_len,
2201                  u16 capa_mask, u16 capa_val),
2202         TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, capa_mask, capa_val),
2203         TP_STRUCT__entry(
2204                 WIPHY_ENTRY
2205                 CHAN_ENTRY
2206                 MAC_ENTRY(bssid)
2207                 __dynamic_array(u8, ssid, ssid_len)
2208                 __field(u16, capa_mask)
2209                 __field(u16, capa_val)
2210         ),
2211         TP_fast_assign(
2212                 WIPHY_ASSIGN;
2213                 CHAN_ASSIGN(channel);
2214                 MAC_ASSIGN(bssid, bssid);
2215                 memcpy(__get_dynamic_array(ssid), ssid, ssid_len);
2216                 __entry->capa_mask = capa_mask;
2217                 __entry->capa_val = capa_val;
2218         ),
2219         TP_printk(WIPHY_PR_FMT CHAN_PR_FMT MAC_PR_FMT ", buf: %#.2x, "
2220                   "capa_mask: %d, capa_val: %u", WIPHY_PR_ARG, CHAN_PR_ARG,
2221                   MAC_PR_ARG(bssid), ((u8 *)__get_dynamic_array(ssid))[0],
2222                   __entry->capa_mask, __entry->capa_val)
2223 );
2224
2225 TRACE_EVENT(cfg80211_inform_bss_frame,
2226         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
2227                  struct ieee80211_mgmt *mgmt, size_t len,
2228                  s32 signal),
2229         TP_ARGS(wiphy, channel, mgmt, len, signal),
2230         TP_STRUCT__entry(
2231                 WIPHY_ENTRY
2232                 CHAN_ENTRY
2233                 __dynamic_array(u8, mgmt, len)
2234                 __field(s32, signal)
2235         ),
2236         TP_fast_assign(
2237                 WIPHY_ASSIGN;
2238                 CHAN_ASSIGN(channel);
2239                 if (mgmt)
2240                         memcpy(__get_dynamic_array(mgmt), mgmt, len);
2241                 __entry->signal = signal;
2242         ),
2243         TP_printk(WIPHY_PR_FMT CHAN_PR_FMT "signal: %d",
2244                   WIPHY_PR_ARG, CHAN_PR_ARG, __entry->signal)
2245 );
2246
2247 DECLARE_EVENT_CLASS(cfg80211_bss_evt,
2248         TP_PROTO(struct cfg80211_bss *pub),
2249         TP_ARGS(pub),
2250         TP_STRUCT__entry(
2251                 MAC_ENTRY(bssid)
2252                 CHAN_ENTRY
2253         ),
2254         TP_fast_assign(
2255                 MAC_ASSIGN(bssid, pub->bssid);
2256                 CHAN_ASSIGN(pub->channel);
2257         ),
2258         TP_printk(MAC_PR_FMT CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG)
2259 );
2260
2261 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss,
2262         TP_PROTO(struct cfg80211_bss *pub),
2263         TP_ARGS(pub)
2264 );
2265
2266 TRACE_EVENT(cfg80211_return_uint,
2267         TP_PROTO(unsigned int ret),
2268         TP_ARGS(ret),
2269         TP_STRUCT__entry(
2270                 __field(unsigned int, ret)
2271         ),
2272         TP_fast_assign(
2273                 __entry->ret = ret;
2274         ),
2275         TP_printk("ret: %d", __entry->ret)
2276 );
2277
2278 TRACE_EVENT(cfg80211_return_u32,
2279         TP_PROTO(u32 ret),
2280         TP_ARGS(ret),
2281         TP_STRUCT__entry(
2282                 __field(u32, ret)
2283         ),
2284         TP_fast_assign(
2285                 __entry->ret = ret;
2286         ),
2287         TP_printk("ret: %u", __entry->ret)
2288 );
2289
2290 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */
2291
2292 #undef TRACE_INCLUDE_PATH
2293 #define TRACE_INCLUDE_PATH .
2294 #undef TRACE_INCLUDE_FILE
2295 #define TRACE_INCLUDE_FILE trace
2296 #include <trace/define_trace.h>