r8169: remove the obsolete and incorrect AMD workaround
[~shefty/rdma-dev.git] / net / mac80211 / cfg.c
1 /*
2  * mac80211 configuration hooks for cfg80211
3  *
4  * Copyright 2006-2010  Johannes Berg <johannes@sipsolutions.net>
5  *
6  * This file is GPLv2 as found in COPYING.
7  */
8
9 #include <linux/ieee80211.h>
10 #include <linux/nl80211.h>
11 #include <linux/rtnetlink.h>
12 #include <linux/slab.h>
13 #include <net/net_namespace.h>
14 #include <linux/rcupdate.h>
15 #include <linux/if_ether.h>
16 #include <net/cfg80211.h>
17 #include "ieee80211_i.h"
18 #include "driver-ops.h"
19 #include "cfg.h"
20 #include "rate.h"
21 #include "mesh.h"
22
23 static struct wireless_dev *ieee80211_add_iface(struct wiphy *wiphy,
24                                                 const char *name,
25                                                 enum nl80211_iftype type,
26                                                 u32 *flags,
27                                                 struct vif_params *params)
28 {
29         struct ieee80211_local *local = wiphy_priv(wiphy);
30         struct wireless_dev *wdev;
31         struct ieee80211_sub_if_data *sdata;
32         int err;
33
34         err = ieee80211_if_add(local, name, &wdev, type, params);
35         if (err)
36                 return ERR_PTR(err);
37
38         if (type == NL80211_IFTYPE_MONITOR && flags) {
39                 sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
40                 sdata->u.mntr_flags = *flags;
41         }
42
43         return wdev;
44 }
45
46 static int ieee80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
47 {
48         ieee80211_if_remove(IEEE80211_WDEV_TO_SUB_IF(wdev));
49
50         return 0;
51 }
52
53 static int ieee80211_change_iface(struct wiphy *wiphy,
54                                   struct net_device *dev,
55                                   enum nl80211_iftype type, u32 *flags,
56                                   struct vif_params *params)
57 {
58         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
59         int ret;
60
61         ret = ieee80211_if_change_type(sdata, type);
62         if (ret)
63                 return ret;
64
65         if (type == NL80211_IFTYPE_AP_VLAN &&
66             params && params->use_4addr == 0)
67                 RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
68         else if (type == NL80211_IFTYPE_STATION &&
69                  params && params->use_4addr >= 0)
70                 sdata->u.mgd.use_4addr = params->use_4addr;
71
72         if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) {
73                 struct ieee80211_local *local = sdata->local;
74
75                 if (ieee80211_sdata_running(sdata)) {
76                         /*
77                          * Prohibit MONITOR_FLAG_COOK_FRAMES to be
78                          * changed while the interface is up.
79                          * Else we would need to add a lot of cruft
80                          * to update everything:
81                          *      cooked_mntrs, monitor and all fif_* counters
82                          *      reconfigure hardware
83                          */
84                         if ((*flags & MONITOR_FLAG_COOK_FRAMES) !=
85                             (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
86                                 return -EBUSY;
87
88                         ieee80211_adjust_monitor_flags(sdata, -1);
89                         sdata->u.mntr_flags = *flags;
90                         ieee80211_adjust_monitor_flags(sdata, 1);
91
92                         ieee80211_configure_filter(local);
93                 } else {
94                         /*
95                          * Because the interface is down, ieee80211_do_stop
96                          * and ieee80211_do_open take care of "everything"
97                          * mentioned in the comment above.
98                          */
99                         sdata->u.mntr_flags = *flags;
100                 }
101         }
102
103         return 0;
104 }
105
106 static int ieee80211_start_p2p_device(struct wiphy *wiphy,
107                                       struct wireless_dev *wdev)
108 {
109         return ieee80211_do_open(wdev, true);
110 }
111
112 static void ieee80211_stop_p2p_device(struct wiphy *wiphy,
113                                       struct wireless_dev *wdev)
114 {
115         ieee80211_sdata_stop(IEEE80211_WDEV_TO_SUB_IF(wdev));
116 }
117
118 static int ieee80211_set_noack_map(struct wiphy *wiphy,
119                                   struct net_device *dev,
120                                   u16 noack_map)
121 {
122         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
123
124         sdata->noack_map = noack_map;
125         return 0;
126 }
127
128 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
129                              u8 key_idx, bool pairwise, const u8 *mac_addr,
130                              struct key_params *params)
131 {
132         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
133         struct sta_info *sta = NULL;
134         struct ieee80211_key *key;
135         int err;
136
137         if (!ieee80211_sdata_running(sdata))
138                 return -ENETDOWN;
139
140         /* reject WEP and TKIP keys if WEP failed to initialize */
141         switch (params->cipher) {
142         case WLAN_CIPHER_SUITE_WEP40:
143         case WLAN_CIPHER_SUITE_TKIP:
144         case WLAN_CIPHER_SUITE_WEP104:
145                 if (IS_ERR(sdata->local->wep_tx_tfm))
146                         return -EINVAL;
147                 break;
148         default:
149                 break;
150         }
151
152         key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
153                                   params->key, params->seq_len, params->seq);
154         if (IS_ERR(key))
155                 return PTR_ERR(key);
156
157         if (pairwise)
158                 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
159
160         mutex_lock(&sdata->local->sta_mtx);
161
162         if (mac_addr) {
163                 if (ieee80211_vif_is_mesh(&sdata->vif))
164                         sta = sta_info_get(sdata, mac_addr);
165                 else
166                         sta = sta_info_get_bss(sdata, mac_addr);
167                 if (!sta) {
168                         ieee80211_key_free(sdata->local, key);
169                         err = -ENOENT;
170                         goto out_unlock;
171                 }
172         }
173
174         switch (sdata->vif.type) {
175         case NL80211_IFTYPE_STATION:
176                 if (sdata->u.mgd.mfp != IEEE80211_MFP_DISABLED)
177                         key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
178                 break;
179         case NL80211_IFTYPE_AP:
180         case NL80211_IFTYPE_AP_VLAN:
181                 /* Keys without a station are used for TX only */
182                 if (key->sta && test_sta_flag(key->sta, WLAN_STA_MFP))
183                         key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
184                 break;
185         case NL80211_IFTYPE_ADHOC:
186                 /* no MFP (yet) */
187                 break;
188         case NL80211_IFTYPE_MESH_POINT:
189 #ifdef CONFIG_MAC80211_MESH
190                 if (sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
191                         key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
192                 break;
193 #endif
194         case NL80211_IFTYPE_WDS:
195         case NL80211_IFTYPE_MONITOR:
196         case NL80211_IFTYPE_P2P_DEVICE:
197         case NL80211_IFTYPE_UNSPECIFIED:
198         case NUM_NL80211_IFTYPES:
199         case NL80211_IFTYPE_P2P_CLIENT:
200         case NL80211_IFTYPE_P2P_GO:
201                 /* shouldn't happen */
202                 WARN_ON_ONCE(1);
203                 break;
204         }
205
206         err = ieee80211_key_link(key, sdata, sta);
207         if (err)
208                 ieee80211_key_free(sdata->local, key);
209
210  out_unlock:
211         mutex_unlock(&sdata->local->sta_mtx);
212
213         return err;
214 }
215
216 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
217                              u8 key_idx, bool pairwise, const u8 *mac_addr)
218 {
219         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
220         struct ieee80211_local *local = sdata->local;
221         struct sta_info *sta;
222         struct ieee80211_key *key = NULL;
223         int ret;
224
225         mutex_lock(&local->sta_mtx);
226         mutex_lock(&local->key_mtx);
227
228         if (mac_addr) {
229                 ret = -ENOENT;
230
231                 sta = sta_info_get_bss(sdata, mac_addr);
232                 if (!sta)
233                         goto out_unlock;
234
235                 if (pairwise)
236                         key = key_mtx_dereference(local, sta->ptk);
237                 else
238                         key = key_mtx_dereference(local, sta->gtk[key_idx]);
239         } else
240                 key = key_mtx_dereference(local, sdata->keys[key_idx]);
241
242         if (!key) {
243                 ret = -ENOENT;
244                 goto out_unlock;
245         }
246
247         __ieee80211_key_free(key);
248
249         ret = 0;
250  out_unlock:
251         mutex_unlock(&local->key_mtx);
252         mutex_unlock(&local->sta_mtx);
253
254         return ret;
255 }
256
257 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
258                              u8 key_idx, bool pairwise, const u8 *mac_addr,
259                              void *cookie,
260                              void (*callback)(void *cookie,
261                                               struct key_params *params))
262 {
263         struct ieee80211_sub_if_data *sdata;
264         struct sta_info *sta = NULL;
265         u8 seq[6] = {0};
266         struct key_params params;
267         struct ieee80211_key *key = NULL;
268         u64 pn64;
269         u32 iv32;
270         u16 iv16;
271         int err = -ENOENT;
272
273         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
274
275         rcu_read_lock();
276
277         if (mac_addr) {
278                 sta = sta_info_get_bss(sdata, mac_addr);
279                 if (!sta)
280                         goto out;
281
282                 if (pairwise)
283                         key = rcu_dereference(sta->ptk);
284                 else if (key_idx < NUM_DEFAULT_KEYS)
285                         key = rcu_dereference(sta->gtk[key_idx]);
286         } else
287                 key = rcu_dereference(sdata->keys[key_idx]);
288
289         if (!key)
290                 goto out;
291
292         memset(&params, 0, sizeof(params));
293
294         params.cipher = key->conf.cipher;
295
296         switch (key->conf.cipher) {
297         case WLAN_CIPHER_SUITE_TKIP:
298                 iv32 = key->u.tkip.tx.iv32;
299                 iv16 = key->u.tkip.tx.iv16;
300
301                 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
302                         drv_get_tkip_seq(sdata->local,
303                                          key->conf.hw_key_idx,
304                                          &iv32, &iv16);
305
306                 seq[0] = iv16 & 0xff;
307                 seq[1] = (iv16 >> 8) & 0xff;
308                 seq[2] = iv32 & 0xff;
309                 seq[3] = (iv32 >> 8) & 0xff;
310                 seq[4] = (iv32 >> 16) & 0xff;
311                 seq[5] = (iv32 >> 24) & 0xff;
312                 params.seq = seq;
313                 params.seq_len = 6;
314                 break;
315         case WLAN_CIPHER_SUITE_CCMP:
316                 pn64 = atomic64_read(&key->u.ccmp.tx_pn);
317                 seq[0] = pn64;
318                 seq[1] = pn64 >> 8;
319                 seq[2] = pn64 >> 16;
320                 seq[3] = pn64 >> 24;
321                 seq[4] = pn64 >> 32;
322                 seq[5] = pn64 >> 40;
323                 params.seq = seq;
324                 params.seq_len = 6;
325                 break;
326         case WLAN_CIPHER_SUITE_AES_CMAC:
327                 pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
328                 seq[0] = pn64;
329                 seq[1] = pn64 >> 8;
330                 seq[2] = pn64 >> 16;
331                 seq[3] = pn64 >> 24;
332                 seq[4] = pn64 >> 32;
333                 seq[5] = pn64 >> 40;
334                 params.seq = seq;
335                 params.seq_len = 6;
336                 break;
337         }
338
339         params.key = key->conf.key;
340         params.key_len = key->conf.keylen;
341
342         callback(cookie, &params);
343         err = 0;
344
345  out:
346         rcu_read_unlock();
347         return err;
348 }
349
350 static int ieee80211_config_default_key(struct wiphy *wiphy,
351                                         struct net_device *dev,
352                                         u8 key_idx, bool uni,
353                                         bool multi)
354 {
355         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
356
357         ieee80211_set_default_key(sdata, key_idx, uni, multi);
358
359         return 0;
360 }
361
362 static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
363                                              struct net_device *dev,
364                                              u8 key_idx)
365 {
366         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
367
368         ieee80211_set_default_mgmt_key(sdata, key_idx);
369
370         return 0;
371 }
372
373 void sta_set_rate_info_tx(struct sta_info *sta,
374                           const struct ieee80211_tx_rate *rate,
375                           struct rate_info *rinfo)
376 {
377         rinfo->flags = 0;
378         if (rate->flags & IEEE80211_TX_RC_MCS) {
379                 rinfo->flags |= RATE_INFO_FLAGS_MCS;
380                 rinfo->mcs = rate->idx;
381         } else if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
382                 rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
383                 rinfo->mcs = ieee80211_rate_get_vht_mcs(rate);
384                 rinfo->nss = ieee80211_rate_get_vht_nss(rate);
385         } else {
386                 struct ieee80211_supported_band *sband;
387                 sband = sta->local->hw.wiphy->bands[
388                                 ieee80211_get_sdata_band(sta->sdata)];
389                 rinfo->legacy = sband->bitrates[rate->idx].bitrate;
390         }
391         if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
392                 rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
393         if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
394                 rinfo->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
395         if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
396                 rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
397         if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
398                 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
399 }
400
401 void sta_set_rate_info_rx(struct sta_info *sta, struct rate_info *rinfo)
402 {
403         rinfo->flags = 0;
404
405         if (sta->last_rx_rate_flag & RX_FLAG_HT) {
406                 rinfo->flags |= RATE_INFO_FLAGS_MCS;
407                 rinfo->mcs = sta->last_rx_rate_idx;
408         } else if (sta->last_rx_rate_flag & RX_FLAG_VHT) {
409                 rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
410                 rinfo->nss = sta->last_rx_rate_vht_nss;
411                 rinfo->mcs = sta->last_rx_rate_idx;
412         } else {
413                 struct ieee80211_supported_band *sband;
414
415                 sband = sta->local->hw.wiphy->bands[
416                                 ieee80211_get_sdata_band(sta->sdata)];
417                 rinfo->legacy =
418                         sband->bitrates[sta->last_rx_rate_idx].bitrate;
419         }
420
421         if (sta->last_rx_rate_flag & RX_FLAG_40MHZ)
422                 rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
423         if (sta->last_rx_rate_flag & RX_FLAG_SHORT_GI)
424                 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
425         if (sta->last_rx_rate_flag & RX_FLAG_80MHZ)
426                 rinfo->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
427         if (sta->last_rx_rate_flag & RX_FLAG_80P80MHZ)
428                 rinfo->flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
429         if (sta->last_rx_rate_flag & RX_FLAG_160MHZ)
430                 rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
431 }
432
433 static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
434 {
435         struct ieee80211_sub_if_data *sdata = sta->sdata;
436         struct ieee80211_local *local = sdata->local;
437         struct timespec uptime;
438
439         sinfo->generation = sdata->local->sta_generation;
440
441         sinfo->filled = STATION_INFO_INACTIVE_TIME |
442                         STATION_INFO_RX_BYTES |
443                         STATION_INFO_TX_BYTES |
444                         STATION_INFO_RX_PACKETS |
445                         STATION_INFO_TX_PACKETS |
446                         STATION_INFO_TX_RETRIES |
447                         STATION_INFO_TX_FAILED |
448                         STATION_INFO_TX_BITRATE |
449                         STATION_INFO_RX_BITRATE |
450                         STATION_INFO_RX_DROP_MISC |
451                         STATION_INFO_BSS_PARAM |
452                         STATION_INFO_CONNECTED_TIME |
453                         STATION_INFO_STA_FLAGS |
454                         STATION_INFO_BEACON_LOSS_COUNT;
455
456         do_posix_clock_monotonic_gettime(&uptime);
457         sinfo->connected_time = uptime.tv_sec - sta->last_connected;
458
459         sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
460         sinfo->rx_bytes = sta->rx_bytes;
461         sinfo->tx_bytes = sta->tx_bytes;
462         sinfo->rx_packets = sta->rx_packets;
463         sinfo->tx_packets = sta->tx_packets;
464         sinfo->tx_retries = sta->tx_retry_count;
465         sinfo->tx_failed = sta->tx_retry_failed;
466         sinfo->rx_dropped_misc = sta->rx_dropped;
467         sinfo->beacon_loss_count = sta->beacon_loss_count;
468
469         if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
470             (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
471                 sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
472                 if (!local->ops->get_rssi ||
473                     drv_get_rssi(local, sdata, &sta->sta, &sinfo->signal))
474                         sinfo->signal = (s8)sta->last_signal;
475                 sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
476         }
477
478         sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate);
479         sta_set_rate_info_rx(sta, &sinfo->rxrate);
480
481         if (ieee80211_vif_is_mesh(&sdata->vif)) {
482 #ifdef CONFIG_MAC80211_MESH
483                 sinfo->filled |= STATION_INFO_LLID |
484                                  STATION_INFO_PLID |
485                                  STATION_INFO_PLINK_STATE;
486
487                 sinfo->llid = le16_to_cpu(sta->llid);
488                 sinfo->plid = le16_to_cpu(sta->plid);
489                 sinfo->plink_state = sta->plink_state;
490                 if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
491                         sinfo->filled |= STATION_INFO_T_OFFSET;
492                         sinfo->t_offset = sta->t_offset;
493                 }
494 #endif
495         }
496
497         sinfo->bss_param.flags = 0;
498         if (sdata->vif.bss_conf.use_cts_prot)
499                 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
500         if (sdata->vif.bss_conf.use_short_preamble)
501                 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
502         if (sdata->vif.bss_conf.use_short_slot)
503                 sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
504         sinfo->bss_param.dtim_period = sdata->local->hw.conf.ps_dtim_period;
505         sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
506
507         sinfo->sta_flags.set = 0;
508         sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
509                                 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
510                                 BIT(NL80211_STA_FLAG_WME) |
511                                 BIT(NL80211_STA_FLAG_MFP) |
512                                 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
513                                 BIT(NL80211_STA_FLAG_TDLS_PEER);
514         if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
515                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
516         if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
517                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
518         if (test_sta_flag(sta, WLAN_STA_WME))
519                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
520         if (test_sta_flag(sta, WLAN_STA_MFP))
521                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
522         if (test_sta_flag(sta, WLAN_STA_AUTH))
523                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
524         if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
525                 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
526 }
527
528 static const char ieee80211_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
529         "rx_packets", "rx_bytes", "wep_weak_iv_count",
530         "rx_duplicates", "rx_fragments", "rx_dropped",
531         "tx_packets", "tx_bytes", "tx_fragments",
532         "tx_filtered", "tx_retry_failed", "tx_retries",
533         "beacon_loss", "sta_state", "txrate", "rxrate", "signal",
534         "channel", "noise", "ch_time", "ch_time_busy",
535         "ch_time_ext_busy", "ch_time_rx", "ch_time_tx"
536 };
537 #define STA_STATS_LEN   ARRAY_SIZE(ieee80211_gstrings_sta_stats)
538
539 static int ieee80211_get_et_sset_count(struct wiphy *wiphy,
540                                        struct net_device *dev,
541                                        int sset)
542 {
543         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
544         int rv = 0;
545
546         if (sset == ETH_SS_STATS)
547                 rv += STA_STATS_LEN;
548
549         rv += drv_get_et_sset_count(sdata, sset);
550
551         if (rv == 0)
552                 return -EOPNOTSUPP;
553         return rv;
554 }
555
556 static void ieee80211_get_et_stats(struct wiphy *wiphy,
557                                    struct net_device *dev,
558                                    struct ethtool_stats *stats,
559                                    u64 *data)
560 {
561         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
562         struct ieee80211_chanctx_conf *chanctx_conf;
563         struct ieee80211_channel *channel;
564         struct sta_info *sta;
565         struct ieee80211_local *local = sdata->local;
566         struct station_info sinfo;
567         struct survey_info survey;
568         int i, q;
569 #define STA_STATS_SURVEY_LEN 7
570
571         memset(data, 0, sizeof(u64) * STA_STATS_LEN);
572
573 #define ADD_STA_STATS(sta)                              \
574         do {                                            \
575                 data[i++] += sta->rx_packets;           \
576                 data[i++] += sta->rx_bytes;             \
577                 data[i++] += sta->wep_weak_iv_count;    \
578                 data[i++] += sta->num_duplicates;       \
579                 data[i++] += sta->rx_fragments;         \
580                 data[i++] += sta->rx_dropped;           \
581                                                         \
582                 data[i++] += sta->tx_packets;           \
583                 data[i++] += sta->tx_bytes;             \
584                 data[i++] += sta->tx_fragments;         \
585                 data[i++] += sta->tx_filtered_count;    \
586                 data[i++] += sta->tx_retry_failed;      \
587                 data[i++] += sta->tx_retry_count;       \
588                 data[i++] += sta->beacon_loss_count;    \
589         } while (0)
590
591         /* For Managed stations, find the single station based on BSSID
592          * and use that.  For interface types, iterate through all available
593          * stations and add stats for any station that is assigned to this
594          * network device.
595          */
596
597         mutex_lock(&local->sta_mtx);
598
599         if (sdata->vif.type == NL80211_IFTYPE_STATION) {
600                 sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid);
601
602                 if (!(sta && !WARN_ON(sta->sdata->dev != dev)))
603                         goto do_survey;
604
605                 i = 0;
606                 ADD_STA_STATS(sta);
607
608                 data[i++] = sta->sta_state;
609
610                 sinfo.filled = 0;
611                 sta_set_sinfo(sta, &sinfo);
612
613                 if (sinfo.filled & STATION_INFO_TX_BITRATE)
614                         data[i] = 100000 *
615                                 cfg80211_calculate_bitrate(&sinfo.txrate);
616                 i++;
617                 if (sinfo.filled & STATION_INFO_RX_BITRATE)
618                         data[i] = 100000 *
619                                 cfg80211_calculate_bitrate(&sinfo.rxrate);
620                 i++;
621
622                 if (sinfo.filled & STATION_INFO_SIGNAL_AVG)
623                         data[i] = (u8)sinfo.signal_avg;
624                 i++;
625         } else {
626                 list_for_each_entry(sta, &local->sta_list, list) {
627                         /* Make sure this station belongs to the proper dev */
628                         if (sta->sdata->dev != dev)
629                                 continue;
630
631                         i = 0;
632                         ADD_STA_STATS(sta);
633                 }
634         }
635
636 do_survey:
637         i = STA_STATS_LEN - STA_STATS_SURVEY_LEN;
638         /* Get survey stats for current channel */
639         survey.filled = 0;
640
641         rcu_read_lock();
642         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
643         if (chanctx_conf)
644                 channel = chanctx_conf->def.chan;
645         else
646                 channel = NULL;
647         rcu_read_unlock();
648
649         if (channel) {
650                 q = 0;
651                 do {
652                         survey.filled = 0;
653                         if (drv_get_survey(local, q, &survey) != 0) {
654                                 survey.filled = 0;
655                                 break;
656                         }
657                         q++;
658                 } while (channel != survey.channel);
659         }
660
661         if (survey.filled)
662                 data[i++] = survey.channel->center_freq;
663         else
664                 data[i++] = 0;
665         if (survey.filled & SURVEY_INFO_NOISE_DBM)
666                 data[i++] = (u8)survey.noise;
667         else
668                 data[i++] = -1LL;
669         if (survey.filled & SURVEY_INFO_CHANNEL_TIME)
670                 data[i++] = survey.channel_time;
671         else
672                 data[i++] = -1LL;
673         if (survey.filled & SURVEY_INFO_CHANNEL_TIME_BUSY)
674                 data[i++] = survey.channel_time_busy;
675         else
676                 data[i++] = -1LL;
677         if (survey.filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY)
678                 data[i++] = survey.channel_time_ext_busy;
679         else
680                 data[i++] = -1LL;
681         if (survey.filled & SURVEY_INFO_CHANNEL_TIME_RX)
682                 data[i++] = survey.channel_time_rx;
683         else
684                 data[i++] = -1LL;
685         if (survey.filled & SURVEY_INFO_CHANNEL_TIME_TX)
686                 data[i++] = survey.channel_time_tx;
687         else
688                 data[i++] = -1LL;
689
690         mutex_unlock(&local->sta_mtx);
691
692         if (WARN_ON(i != STA_STATS_LEN))
693                 return;
694
695         drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN]));
696 }
697
698 static void ieee80211_get_et_strings(struct wiphy *wiphy,
699                                      struct net_device *dev,
700                                      u32 sset, u8 *data)
701 {
702         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
703         int sz_sta_stats = 0;
704
705         if (sset == ETH_SS_STATS) {
706                 sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats);
707                 memcpy(data, *ieee80211_gstrings_sta_stats, sz_sta_stats);
708         }
709         drv_get_et_strings(sdata, sset, &(data[sz_sta_stats]));
710 }
711
712 static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
713                                  int idx, u8 *mac, struct station_info *sinfo)
714 {
715         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
716         struct ieee80211_local *local = sdata->local;
717         struct sta_info *sta;
718         int ret = -ENOENT;
719
720         mutex_lock(&local->sta_mtx);
721
722         sta = sta_info_get_by_idx(sdata, idx);
723         if (sta) {
724                 ret = 0;
725                 memcpy(mac, sta->sta.addr, ETH_ALEN);
726                 sta_set_sinfo(sta, sinfo);
727         }
728
729         mutex_unlock(&local->sta_mtx);
730
731         return ret;
732 }
733
734 static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
735                                  int idx, struct survey_info *survey)
736 {
737         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
738
739         return drv_get_survey(local, idx, survey);
740 }
741
742 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
743                                  u8 *mac, struct station_info *sinfo)
744 {
745         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
746         struct ieee80211_local *local = sdata->local;
747         struct sta_info *sta;
748         int ret = -ENOENT;
749
750         mutex_lock(&local->sta_mtx);
751
752         sta = sta_info_get_bss(sdata, mac);
753         if (sta) {
754                 ret = 0;
755                 sta_set_sinfo(sta, sinfo);
756         }
757
758         mutex_unlock(&local->sta_mtx);
759
760         return ret;
761 }
762
763 static int ieee80211_set_monitor_channel(struct wiphy *wiphy,
764                                          struct cfg80211_chan_def *chandef)
765 {
766         struct ieee80211_local *local = wiphy_priv(wiphy);
767         struct ieee80211_sub_if_data *sdata;
768         int ret = 0;
769
770         if (cfg80211_chandef_identical(&local->monitor_chandef, chandef))
771                 return 0;
772
773         mutex_lock(&local->iflist_mtx);
774         if (local->use_chanctx) {
775                 sdata = rcu_dereference_protected(
776                                 local->monitor_sdata,
777                                 lockdep_is_held(&local->iflist_mtx));
778                 if (sdata) {
779                         ieee80211_vif_release_channel(sdata);
780                         ret = ieee80211_vif_use_channel(sdata, chandef,
781                                         IEEE80211_CHANCTX_EXCLUSIVE);
782                 }
783         } else if (local->open_count == local->monitors) {
784                 local->_oper_channel = chandef->chan;
785                 local->_oper_channel_type = cfg80211_get_chandef_type(chandef);
786                 ieee80211_hw_config(local, 0);
787         }
788
789         if (ret == 0)
790                 local->monitor_chandef = *chandef;
791         mutex_unlock(&local->iflist_mtx);
792
793         return ret;
794 }
795
796 static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
797                                     const u8 *resp, size_t resp_len)
798 {
799         struct probe_resp *new, *old;
800
801         if (!resp || !resp_len)
802                 return 1;
803
804         old = rtnl_dereference(sdata->u.ap.probe_resp);
805
806         new = kzalloc(sizeof(struct probe_resp) + resp_len, GFP_KERNEL);
807         if (!new)
808                 return -ENOMEM;
809
810         new->len = resp_len;
811         memcpy(new->data, resp, resp_len);
812
813         rcu_assign_pointer(sdata->u.ap.probe_resp, new);
814         if (old)
815                 kfree_rcu(old, rcu_head);
816
817         return 0;
818 }
819
820 static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
821                                    struct cfg80211_beacon_data *params)
822 {
823         struct beacon_data *new, *old;
824         int new_head_len, new_tail_len;
825         int size, err;
826         u32 changed = BSS_CHANGED_BEACON;
827
828         old = rtnl_dereference(sdata->u.ap.beacon);
829
830         /* Need to have a beacon head if we don't have one yet */
831         if (!params->head && !old)
832                 return -EINVAL;
833
834         /* new or old head? */
835         if (params->head)
836                 new_head_len = params->head_len;
837         else
838                 new_head_len = old->head_len;
839
840         /* new or old tail? */
841         if (params->tail || !old)
842                 /* params->tail_len will be zero for !params->tail */
843                 new_tail_len = params->tail_len;
844         else
845                 new_tail_len = old->tail_len;
846
847         size = sizeof(*new) + new_head_len + new_tail_len;
848
849         new = kzalloc(size, GFP_KERNEL);
850         if (!new)
851                 return -ENOMEM;
852
853         /* start filling the new info now */
854
855         /*
856          * pointers go into the block we allocated,
857          * memory is | beacon_data | head | tail |
858          */
859         new->head = ((u8 *) new) + sizeof(*new);
860         new->tail = new->head + new_head_len;
861         new->head_len = new_head_len;
862         new->tail_len = new_tail_len;
863
864         /* copy in head */
865         if (params->head)
866                 memcpy(new->head, params->head, new_head_len);
867         else
868                 memcpy(new->head, old->head, new_head_len);
869
870         /* copy in optional tail */
871         if (params->tail)
872                 memcpy(new->tail, params->tail, new_tail_len);
873         else
874                 if (old)
875                         memcpy(new->tail, old->tail, new_tail_len);
876
877         err = ieee80211_set_probe_resp(sdata, params->probe_resp,
878                                        params->probe_resp_len);
879         if (err < 0)
880                 return err;
881         if (err == 0)
882                 changed |= BSS_CHANGED_AP_PROBE_RESP;
883
884         rcu_assign_pointer(sdata->u.ap.beacon, new);
885
886         if (old)
887                 kfree_rcu(old, rcu_head);
888
889         return changed;
890 }
891
892 static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
893                               struct cfg80211_ap_settings *params)
894 {
895         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
896         struct beacon_data *old;
897         struct ieee80211_sub_if_data *vlan;
898         u32 changed = BSS_CHANGED_BEACON_INT |
899                       BSS_CHANGED_BEACON_ENABLED |
900                       BSS_CHANGED_BEACON |
901                       BSS_CHANGED_SSID |
902                       BSS_CHANGED_P2P_PS;
903         int err;
904
905         old = rtnl_dereference(sdata->u.ap.beacon);
906         if (old)
907                 return -EALREADY;
908
909         /* TODO: make hostapd tell us what it wants */
910         sdata->smps_mode = IEEE80211_SMPS_OFF;
911         sdata->needed_rx_chains = sdata->local->rx_chains;
912
913         err = ieee80211_vif_use_channel(sdata, &params->chandef,
914                                         IEEE80211_CHANCTX_SHARED);
915         if (err)
916                 return err;
917
918         /*
919          * Apply control port protocol, this allows us to
920          * not encrypt dynamic WEP control frames.
921          */
922         sdata->control_port_protocol = params->crypto.control_port_ethertype;
923         sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt;
924         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
925                 vlan->control_port_protocol =
926                         params->crypto.control_port_ethertype;
927                 vlan->control_port_no_encrypt =
928                         params->crypto.control_port_no_encrypt;
929         }
930
931         sdata->vif.bss_conf.beacon_int = params->beacon_interval;
932         sdata->vif.bss_conf.dtim_period = params->dtim_period;
933
934         sdata->vif.bss_conf.ssid_len = params->ssid_len;
935         if (params->ssid_len)
936                 memcpy(sdata->vif.bss_conf.ssid, params->ssid,
937                        params->ssid_len);
938         sdata->vif.bss_conf.hidden_ssid =
939                 (params->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE);
940
941         sdata->vif.bss_conf.p2p_ctwindow = params->p2p_ctwindow;
942         sdata->vif.bss_conf.p2p_oppps = params->p2p_opp_ps;
943
944         err = ieee80211_assign_beacon(sdata, &params->beacon);
945         if (err < 0)
946                 return err;
947         changed |= err;
948
949         err = drv_start_ap(sdata->local, sdata);
950         if (err) {
951                 old = rtnl_dereference(sdata->u.ap.beacon);
952                 if (old)
953                         kfree_rcu(old, rcu_head);
954                 RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
955                 return err;
956         }
957
958         ieee80211_bss_info_change_notify(sdata, changed);
959
960         netif_carrier_on(dev);
961         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
962                 netif_carrier_on(vlan->dev);
963
964         return 0;
965 }
966
967 static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
968                                    struct cfg80211_beacon_data *params)
969 {
970         struct ieee80211_sub_if_data *sdata;
971         struct beacon_data *old;
972         int err;
973
974         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
975
976         old = rtnl_dereference(sdata->u.ap.beacon);
977         if (!old)
978                 return -ENOENT;
979
980         err = ieee80211_assign_beacon(sdata, params);
981         if (err < 0)
982                 return err;
983         ieee80211_bss_info_change_notify(sdata, err);
984         return 0;
985 }
986
987 static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
988 {
989         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
990         struct ieee80211_sub_if_data *vlan;
991         struct ieee80211_local *local = sdata->local;
992         struct beacon_data *old_beacon;
993         struct probe_resp *old_probe_resp;
994
995         old_beacon = rtnl_dereference(sdata->u.ap.beacon);
996         if (!old_beacon)
997                 return -ENOENT;
998         old_probe_resp = rtnl_dereference(sdata->u.ap.probe_resp);
999
1000         /* turn off carrier for this interface and dependent VLANs */
1001         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1002                 netif_carrier_off(vlan->dev);
1003         netif_carrier_off(dev);
1004
1005         /* remove beacon and probe response */
1006         RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1007         RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
1008         kfree_rcu(old_beacon, rcu_head);
1009         if (old_probe_resp)
1010                 kfree_rcu(old_probe_resp, rcu_head);
1011
1012         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1013                 sta_info_flush(local, vlan);
1014         sta_info_flush(local, sdata);
1015         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
1016
1017         drv_stop_ap(sdata->local, sdata);
1018
1019         /* free all potentially still buffered bcast frames */
1020         local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps.bc_buf);
1021         skb_queue_purge(&sdata->u.ap.ps.bc_buf);
1022
1023         ieee80211_vif_release_channel(sdata);
1024
1025         return 0;
1026 }
1027
1028 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
1029 struct iapp_layer2_update {
1030         u8 da[ETH_ALEN];        /* broadcast */
1031         u8 sa[ETH_ALEN];        /* STA addr */
1032         __be16 len;             /* 6 */
1033         u8 dsap;                /* 0 */
1034         u8 ssap;                /* 0 */
1035         u8 control;
1036         u8 xid_info[3];
1037 } __packed;
1038
1039 static void ieee80211_send_layer2_update(struct sta_info *sta)
1040 {
1041         struct iapp_layer2_update *msg;
1042         struct sk_buff *skb;
1043
1044         /* Send Level 2 Update Frame to update forwarding tables in layer 2
1045          * bridge devices */
1046
1047         skb = dev_alloc_skb(sizeof(*msg));
1048         if (!skb)
1049                 return;
1050         msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg));
1051
1052         /* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
1053          * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */
1054
1055         eth_broadcast_addr(msg->da);
1056         memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
1057         msg->len = htons(6);
1058         msg->dsap = 0;
1059         msg->ssap = 0x01;       /* NULL LSAP, CR Bit: Response */
1060         msg->control = 0xaf;    /* XID response lsb.1111F101.
1061                                  * F=0 (no poll command; unsolicited frame) */
1062         msg->xid_info[0] = 0x81;        /* XID format identifier */
1063         msg->xid_info[1] = 1;   /* LLC types/classes: Type 1 LLC */
1064         msg->xid_info[2] = 0;   /* XID sender's receive window size (RW) */
1065
1066         skb->dev = sta->sdata->dev;
1067         skb->protocol = eth_type_trans(skb, sta->sdata->dev);
1068         memset(skb->cb, 0, sizeof(skb->cb));
1069         netif_rx_ni(skb);
1070 }
1071
1072 static int sta_apply_parameters(struct ieee80211_local *local,
1073                                 struct sta_info *sta,
1074                                 struct station_parameters *params)
1075 {
1076         int ret = 0;
1077         u32 rates;
1078         int i, j;
1079         struct ieee80211_supported_band *sband;
1080         struct ieee80211_sub_if_data *sdata = sta->sdata;
1081         enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
1082         u32 mask, set;
1083
1084         sband = local->hw.wiphy->bands[band];
1085
1086         mask = params->sta_flags_mask;
1087         set = params->sta_flags_set;
1088
1089         /*
1090          * In mesh mode, we can clear AUTHENTICATED flag but must
1091          * also make ASSOCIATED follow appropriately for the driver
1092          * API. See also below, after AUTHORIZED changes.
1093          */
1094         if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) {
1095                 /* cfg80211 should not allow this in non-mesh modes */
1096                 if (WARN_ON(!ieee80211_vif_is_mesh(&sdata->vif)))
1097                         return -EINVAL;
1098
1099                 if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
1100                     !test_sta_flag(sta, WLAN_STA_AUTH)) {
1101                         ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
1102                         if (ret)
1103                                 return ret;
1104                         ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1105                         if (ret)
1106                                 return ret;
1107                 }
1108         }
1109
1110         if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1111                 if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
1112                         ret = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
1113                 else if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1114                         ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1115                 if (ret)
1116                         return ret;
1117         }
1118
1119         if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) {
1120                 /* cfg80211 should not allow this in non-mesh modes */
1121                 if (WARN_ON(!ieee80211_vif_is_mesh(&sdata->vif)))
1122                         return -EINVAL;
1123
1124                 if (!(set & BIT(NL80211_STA_FLAG_AUTHENTICATED)) &&
1125                     test_sta_flag(sta, WLAN_STA_AUTH)) {
1126                         ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
1127                         if (ret)
1128                                 return ret;
1129                         ret = sta_info_move_state(sta, IEEE80211_STA_NONE);
1130                         if (ret)
1131                                 return ret;
1132                 }
1133         }
1134
1135
1136         if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
1137                 if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
1138                         set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1139                 else
1140                         clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1141         }
1142
1143         if (mask & BIT(NL80211_STA_FLAG_WME)) {
1144                 if (set & BIT(NL80211_STA_FLAG_WME)) {
1145                         set_sta_flag(sta, WLAN_STA_WME);
1146                         sta->sta.wme = true;
1147                 } else {
1148                         clear_sta_flag(sta, WLAN_STA_WME);
1149                         sta->sta.wme = false;
1150                 }
1151         }
1152
1153         if (mask & BIT(NL80211_STA_FLAG_MFP)) {
1154                 if (set & BIT(NL80211_STA_FLAG_MFP))
1155                         set_sta_flag(sta, WLAN_STA_MFP);
1156                 else
1157                         clear_sta_flag(sta, WLAN_STA_MFP);
1158         }
1159
1160         if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
1161                 if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
1162                         set_sta_flag(sta, WLAN_STA_TDLS_PEER);
1163                 else
1164                         clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
1165         }
1166
1167         if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
1168                 sta->sta.uapsd_queues = params->uapsd_queues;
1169                 sta->sta.max_sp = params->max_sp;
1170         }
1171
1172         /*
1173          * cfg80211 validates this (1-2007) and allows setting the AID
1174          * only when creating a new station entry
1175          */
1176         if (params->aid)
1177                 sta->sta.aid = params->aid;
1178
1179         /*
1180          * FIXME: updating the following information is racy when this
1181          *        function is called from ieee80211_change_station().
1182          *        However, all this information should be static so
1183          *        maybe we should just reject attemps to change it.
1184          */
1185
1186         if (params->listen_interval >= 0)
1187                 sta->listen_interval = params->listen_interval;
1188
1189         if (params->supported_rates) {
1190                 rates = 0;
1191
1192                 for (i = 0; i < params->supported_rates_len; i++) {
1193                         int rate = (params->supported_rates[i] & 0x7f) * 5;
1194                         for (j = 0; j < sband->n_bitrates; j++) {
1195                                 if (sband->bitrates[j].bitrate == rate)
1196                                         rates |= BIT(j);
1197                         }
1198                 }
1199                 sta->sta.supp_rates[band] = rates;
1200         }
1201
1202         if (params->ht_capa)
1203                 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1204                                                   params->ht_capa,
1205                                                   &sta->sta.ht_cap);
1206
1207         if (params->vht_capa)
1208                 ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1209                                                     params->vht_capa,
1210                                                     &sta->sta.vht_cap);
1211
1212         if (ieee80211_vif_is_mesh(&sdata->vif)) {
1213 #ifdef CONFIG_MAC80211_MESH
1214                 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_SECURED)
1215                         switch (params->plink_state) {
1216                         case NL80211_PLINK_LISTEN:
1217                         case NL80211_PLINK_ESTAB:
1218                         case NL80211_PLINK_BLOCKED:
1219                                 sta->plink_state = params->plink_state;
1220                                 break;
1221                         default:
1222                                 /*  nothing  */
1223                                 break;
1224                         }
1225                 else
1226                         switch (params->plink_action) {
1227                         case PLINK_ACTION_OPEN:
1228                                 mesh_plink_open(sta);
1229                                 break;
1230                         case PLINK_ACTION_BLOCK:
1231                                 mesh_plink_block(sta);
1232                                 break;
1233                         }
1234 #endif
1235         }
1236
1237         return 0;
1238 }
1239
1240 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
1241                                  u8 *mac, struct station_parameters *params)
1242 {
1243         struct ieee80211_local *local = wiphy_priv(wiphy);
1244         struct sta_info *sta;
1245         struct ieee80211_sub_if_data *sdata;
1246         int err;
1247         int layer2_update;
1248
1249         if (params->vlan) {
1250                 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
1251
1252                 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1253                     sdata->vif.type != NL80211_IFTYPE_AP)
1254                         return -EINVAL;
1255         } else
1256                 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1257
1258         if (ether_addr_equal(mac, sdata->vif.addr))
1259                 return -EINVAL;
1260
1261         if (is_multicast_ether_addr(mac))
1262                 return -EINVAL;
1263
1264         sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
1265         if (!sta)
1266                 return -ENOMEM;
1267
1268         sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
1269         sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
1270
1271         err = sta_apply_parameters(local, sta, params);
1272         if (err) {
1273                 sta_info_free(local, sta);
1274                 return err;
1275         }
1276
1277         /*
1278          * for TDLS, rate control should be initialized only when supported
1279          * rates are known.
1280          */
1281         if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER))
1282                 rate_control_rate_init(sta);
1283
1284         layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
1285                 sdata->vif.type == NL80211_IFTYPE_AP;
1286
1287         err = sta_info_insert_rcu(sta);
1288         if (err) {
1289                 rcu_read_unlock();
1290                 return err;
1291         }
1292
1293         if (layer2_update)
1294                 ieee80211_send_layer2_update(sta);
1295
1296         rcu_read_unlock();
1297
1298         return 0;
1299 }
1300
1301 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
1302                                  u8 *mac)
1303 {
1304         struct ieee80211_local *local = wiphy_priv(wiphy);
1305         struct ieee80211_sub_if_data *sdata;
1306
1307         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1308
1309         if (mac)
1310                 return sta_info_destroy_addr_bss(sdata, mac);
1311
1312         sta_info_flush(local, sdata);
1313         return 0;
1314 }
1315
1316 static int ieee80211_change_station(struct wiphy *wiphy,
1317                                     struct net_device *dev,
1318                                     u8 *mac,
1319                                     struct station_parameters *params)
1320 {
1321         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1322         struct ieee80211_local *local = wiphy_priv(wiphy);
1323         struct sta_info *sta;
1324         struct ieee80211_sub_if_data *vlansdata;
1325         int err;
1326
1327         mutex_lock(&local->sta_mtx);
1328
1329         sta = sta_info_get_bss(sdata, mac);
1330         if (!sta) {
1331                 mutex_unlock(&local->sta_mtx);
1332                 return -ENOENT;
1333         }
1334
1335         /* in station mode, supported rates are only valid with TDLS */
1336         if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1337             params->supported_rates &&
1338             !test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
1339                 mutex_unlock(&local->sta_mtx);
1340                 return -EINVAL;
1341         }
1342
1343         if (params->vlan && params->vlan != sta->sdata->dev) {
1344                 bool prev_4addr = false;
1345                 bool new_4addr = false;
1346
1347                 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
1348
1349                 if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1350                     vlansdata->vif.type != NL80211_IFTYPE_AP) {
1351                         mutex_unlock(&local->sta_mtx);
1352                         return -EINVAL;
1353                 }
1354
1355                 if (params->vlan->ieee80211_ptr->use_4addr) {
1356                         if (vlansdata->u.vlan.sta) {
1357                                 mutex_unlock(&local->sta_mtx);
1358                                 return -EBUSY;
1359                         }
1360
1361                         rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
1362                         new_4addr = true;
1363                 }
1364
1365                 if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1366                     sta->sdata->u.vlan.sta) {
1367                         rcu_assign_pointer(sta->sdata->u.vlan.sta, NULL);
1368                         prev_4addr = true;
1369                 }
1370
1371                 sta->sdata = vlansdata;
1372
1373                 if (sta->sta_state == IEEE80211_STA_AUTHORIZED &&
1374                     prev_4addr != new_4addr) {
1375                         if (new_4addr)
1376                                 atomic_dec(&sta->sdata->bss->num_mcast_sta);
1377                         else
1378                                 atomic_inc(&sta->sdata->bss->num_mcast_sta);
1379                 }
1380
1381                 ieee80211_send_layer2_update(sta);
1382         }
1383
1384         err = sta_apply_parameters(local, sta, params);
1385         if (err) {
1386                 mutex_unlock(&local->sta_mtx);
1387                 return err;
1388         }
1389
1390         if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) && params->supported_rates)
1391                 rate_control_rate_init(sta);
1392
1393         mutex_unlock(&local->sta_mtx);
1394
1395         if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1396             params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1397                 ieee80211_recalc_ps(local, -1);
1398                 ieee80211_recalc_ps_vif(sdata);
1399         }
1400         return 0;
1401 }
1402
1403 #ifdef CONFIG_MAC80211_MESH
1404 static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
1405                                  u8 *dst, u8 *next_hop)
1406 {
1407         struct ieee80211_sub_if_data *sdata;
1408         struct mesh_path *mpath;
1409         struct sta_info *sta;
1410         int err;
1411
1412         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1413
1414         rcu_read_lock();
1415         sta = sta_info_get(sdata, next_hop);
1416         if (!sta) {
1417                 rcu_read_unlock();
1418                 return -ENOENT;
1419         }
1420
1421         err = mesh_path_add(dst, sdata);
1422         if (err) {
1423                 rcu_read_unlock();
1424                 return err;
1425         }
1426
1427         mpath = mesh_path_lookup(dst, sdata);
1428         if (!mpath) {
1429                 rcu_read_unlock();
1430                 return -ENXIO;
1431         }
1432         mesh_path_fix_nexthop(mpath, sta);
1433
1434         rcu_read_unlock();
1435         return 0;
1436 }
1437
1438 static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
1439                                  u8 *dst)
1440 {
1441         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1442
1443         if (dst)
1444                 return mesh_path_del(dst, sdata);
1445
1446         mesh_path_flush_by_iface(sdata);
1447         return 0;
1448 }
1449
1450 static int ieee80211_change_mpath(struct wiphy *wiphy,
1451                                     struct net_device *dev,
1452                                     u8 *dst, u8 *next_hop)
1453 {
1454         struct ieee80211_sub_if_data *sdata;
1455         struct mesh_path *mpath;
1456         struct sta_info *sta;
1457
1458         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1459
1460         rcu_read_lock();
1461
1462         sta = sta_info_get(sdata, next_hop);
1463         if (!sta) {
1464                 rcu_read_unlock();
1465                 return -ENOENT;
1466         }
1467
1468         mpath = mesh_path_lookup(dst, sdata);
1469         if (!mpath) {
1470                 rcu_read_unlock();
1471                 return -ENOENT;
1472         }
1473
1474         mesh_path_fix_nexthop(mpath, sta);
1475
1476         rcu_read_unlock();
1477         return 0;
1478 }
1479
1480 static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
1481                             struct mpath_info *pinfo)
1482 {
1483         struct sta_info *next_hop_sta = rcu_dereference(mpath->next_hop);
1484
1485         if (next_hop_sta)
1486                 memcpy(next_hop, next_hop_sta->sta.addr, ETH_ALEN);
1487         else
1488                 memset(next_hop, 0, ETH_ALEN);
1489
1490         memset(pinfo, 0, sizeof(*pinfo));
1491
1492         pinfo->generation = mesh_paths_generation;
1493
1494         pinfo->filled = MPATH_INFO_FRAME_QLEN |
1495                         MPATH_INFO_SN |
1496                         MPATH_INFO_METRIC |
1497                         MPATH_INFO_EXPTIME |
1498                         MPATH_INFO_DISCOVERY_TIMEOUT |
1499                         MPATH_INFO_DISCOVERY_RETRIES |
1500                         MPATH_INFO_FLAGS;
1501
1502         pinfo->frame_qlen = mpath->frame_queue.qlen;
1503         pinfo->sn = mpath->sn;
1504         pinfo->metric = mpath->metric;
1505         if (time_before(jiffies, mpath->exp_time))
1506                 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
1507         pinfo->discovery_timeout =
1508                         jiffies_to_msecs(mpath->discovery_timeout);
1509         pinfo->discovery_retries = mpath->discovery_retries;
1510         if (mpath->flags & MESH_PATH_ACTIVE)
1511                 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
1512         if (mpath->flags & MESH_PATH_RESOLVING)
1513                 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
1514         if (mpath->flags & MESH_PATH_SN_VALID)
1515                 pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
1516         if (mpath->flags & MESH_PATH_FIXED)
1517                 pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
1518         if (mpath->flags & MESH_PATH_RESOLVED)
1519                 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVED;
1520 }
1521
1522 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
1523                                u8 *dst, u8 *next_hop, struct mpath_info *pinfo)
1524
1525 {
1526         struct ieee80211_sub_if_data *sdata;
1527         struct mesh_path *mpath;
1528
1529         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1530
1531         rcu_read_lock();
1532         mpath = mesh_path_lookup(dst, sdata);
1533         if (!mpath) {
1534                 rcu_read_unlock();
1535                 return -ENOENT;
1536         }
1537         memcpy(dst, mpath->dst, ETH_ALEN);
1538         mpath_set_pinfo(mpath, next_hop, pinfo);
1539         rcu_read_unlock();
1540         return 0;
1541 }
1542
1543 static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
1544                                  int idx, u8 *dst, u8 *next_hop,
1545                                  struct mpath_info *pinfo)
1546 {
1547         struct ieee80211_sub_if_data *sdata;
1548         struct mesh_path *mpath;
1549
1550         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1551
1552         rcu_read_lock();
1553         mpath = mesh_path_lookup_by_idx(idx, sdata);
1554         if (!mpath) {
1555                 rcu_read_unlock();
1556                 return -ENOENT;
1557         }
1558         memcpy(dst, mpath->dst, ETH_ALEN);
1559         mpath_set_pinfo(mpath, next_hop, pinfo);
1560         rcu_read_unlock();
1561         return 0;
1562 }
1563
1564 static int ieee80211_get_mesh_config(struct wiphy *wiphy,
1565                                 struct net_device *dev,
1566                                 struct mesh_config *conf)
1567 {
1568         struct ieee80211_sub_if_data *sdata;
1569         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1570
1571         memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
1572         return 0;
1573 }
1574
1575 static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
1576 {
1577         return (mask >> (parm-1)) & 0x1;
1578 }
1579
1580 static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
1581                 const struct mesh_setup *setup)
1582 {
1583         u8 *new_ie;
1584         const u8 *old_ie;
1585         struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
1586                                         struct ieee80211_sub_if_data, u.mesh);
1587
1588         /* allocate information elements */
1589         new_ie = NULL;
1590         old_ie = ifmsh->ie;
1591
1592         if (setup->ie_len) {
1593                 new_ie = kmemdup(setup->ie, setup->ie_len,
1594                                 GFP_KERNEL);
1595                 if (!new_ie)
1596                         return -ENOMEM;
1597         }
1598         ifmsh->ie_len = setup->ie_len;
1599         ifmsh->ie = new_ie;
1600         kfree(old_ie);
1601
1602         /* now copy the rest of the setup parameters */
1603         ifmsh->mesh_id_len = setup->mesh_id_len;
1604         memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len);
1605         ifmsh->mesh_sp_id = setup->sync_method;
1606         ifmsh->mesh_pp_id = setup->path_sel_proto;
1607         ifmsh->mesh_pm_id = setup->path_metric;
1608         ifmsh->security = IEEE80211_MESH_SEC_NONE;
1609         if (setup->is_authenticated)
1610                 ifmsh->security |= IEEE80211_MESH_SEC_AUTHED;
1611         if (setup->is_secure)
1612                 ifmsh->security |= IEEE80211_MESH_SEC_SECURED;
1613
1614         /* mcast rate setting in Mesh Node */
1615         memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
1616                                                 sizeof(setup->mcast_rate));
1617
1618         return 0;
1619 }
1620
1621 static int ieee80211_update_mesh_config(struct wiphy *wiphy,
1622                                         struct net_device *dev, u32 mask,
1623                                         const struct mesh_config *nconf)
1624 {
1625         struct mesh_config *conf;
1626         struct ieee80211_sub_if_data *sdata;
1627         struct ieee80211_if_mesh *ifmsh;
1628
1629         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1630         ifmsh = &sdata->u.mesh;
1631
1632         /* Set the config options which we are interested in setting */
1633         conf = &(sdata->u.mesh.mshcfg);
1634         if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
1635                 conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
1636         if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
1637                 conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
1638         if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
1639                 conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
1640         if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
1641                 conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
1642         if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
1643                 conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
1644         if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
1645                 conf->dot11MeshTTL = nconf->dot11MeshTTL;
1646         if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
1647                 conf->element_ttl = nconf->element_ttl;
1648         if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))
1649                 conf->auto_open_plinks = nconf->auto_open_plinks;
1650         if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask))
1651                 conf->dot11MeshNbrOffsetMaxNeighbor =
1652                         nconf->dot11MeshNbrOffsetMaxNeighbor;
1653         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
1654                 conf->dot11MeshHWMPmaxPREQretries =
1655                         nconf->dot11MeshHWMPmaxPREQretries;
1656         if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
1657                 conf->path_refresh_time = nconf->path_refresh_time;
1658         if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
1659                 conf->min_discovery_timeout = nconf->min_discovery_timeout;
1660         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
1661                 conf->dot11MeshHWMPactivePathTimeout =
1662                         nconf->dot11MeshHWMPactivePathTimeout;
1663         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
1664                 conf->dot11MeshHWMPpreqMinInterval =
1665                         nconf->dot11MeshHWMPpreqMinInterval;
1666         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
1667                 conf->dot11MeshHWMPperrMinInterval =
1668                         nconf->dot11MeshHWMPperrMinInterval;
1669         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
1670                            mask))
1671                 conf->dot11MeshHWMPnetDiameterTraversalTime =
1672                         nconf->dot11MeshHWMPnetDiameterTraversalTime;
1673         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
1674                 conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
1675                 ieee80211_mesh_root_setup(ifmsh);
1676         }
1677         if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
1678                 /* our current gate announcement implementation rides on root
1679                  * announcements, so require this ifmsh to also be a root node
1680                  * */
1681                 if (nconf->dot11MeshGateAnnouncementProtocol &&
1682                     !(conf->dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)) {
1683                         conf->dot11MeshHWMPRootMode = IEEE80211_PROACTIVE_RANN;
1684                         ieee80211_mesh_root_setup(ifmsh);
1685                 }
1686                 conf->dot11MeshGateAnnouncementProtocol =
1687                         nconf->dot11MeshGateAnnouncementProtocol;
1688         }
1689         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask))
1690                 conf->dot11MeshHWMPRannInterval =
1691                         nconf->dot11MeshHWMPRannInterval;
1692         if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask))
1693                 conf->dot11MeshForwarding = nconf->dot11MeshForwarding;
1694         if (_chg_mesh_attr(NL80211_MESHCONF_RSSI_THRESHOLD, mask)) {
1695                 /* our RSSI threshold implementation is supported only for
1696                  * devices that report signal in dBm.
1697                  */
1698                 if (!(sdata->local->hw.flags & IEEE80211_HW_SIGNAL_DBM))
1699                         return -ENOTSUPP;
1700                 conf->rssi_threshold = nconf->rssi_threshold;
1701         }
1702         if (_chg_mesh_attr(NL80211_MESHCONF_HT_OPMODE, mask)) {
1703                 conf->ht_opmode = nconf->ht_opmode;
1704                 sdata->vif.bss_conf.ht_operation_mode = nconf->ht_opmode;
1705                 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);
1706         }
1707         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, mask))
1708                 conf->dot11MeshHWMPactivePathToRootTimeout =
1709                         nconf->dot11MeshHWMPactivePathToRootTimeout;
1710         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOT_INTERVAL, mask))
1711                 conf->dot11MeshHWMProotInterval =
1712                         nconf->dot11MeshHWMProotInterval;
1713         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, mask))
1714                 conf->dot11MeshHWMPconfirmationInterval =
1715                         nconf->dot11MeshHWMPconfirmationInterval;
1716         return 0;
1717 }
1718
1719 static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev,
1720                                const struct mesh_config *conf,
1721                                const struct mesh_setup *setup)
1722 {
1723         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1724         struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1725         int err;
1726
1727         memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
1728         err = copy_mesh_setup(ifmsh, setup);
1729         if (err)
1730                 return err;
1731
1732         /* can mesh use other SMPS modes? */
1733         sdata->smps_mode = IEEE80211_SMPS_OFF;
1734         sdata->needed_rx_chains = sdata->local->rx_chains;
1735
1736         err = ieee80211_vif_use_channel(sdata, &setup->chandef,
1737                                         IEEE80211_CHANCTX_SHARED);
1738         if (err)
1739                 return err;
1740
1741         ieee80211_start_mesh(sdata);
1742
1743         return 0;
1744 }
1745
1746 static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev)
1747 {
1748         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1749
1750         ieee80211_stop_mesh(sdata);
1751         ieee80211_vif_release_channel(sdata);
1752
1753         return 0;
1754 }
1755 #endif
1756
1757 static int ieee80211_change_bss(struct wiphy *wiphy,
1758                                 struct net_device *dev,
1759                                 struct bss_parameters *params)
1760 {
1761         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1762         enum ieee80211_band band;
1763         u32 changed = 0;
1764
1765         if (!rtnl_dereference(sdata->u.ap.beacon))
1766                 return -ENOENT;
1767
1768         band = ieee80211_get_sdata_band(sdata);
1769
1770         if (params->use_cts_prot >= 0) {
1771                 sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
1772                 changed |= BSS_CHANGED_ERP_CTS_PROT;
1773         }
1774         if (params->use_short_preamble >= 0) {
1775                 sdata->vif.bss_conf.use_short_preamble =
1776                         params->use_short_preamble;
1777                 changed |= BSS_CHANGED_ERP_PREAMBLE;
1778         }
1779
1780         if (!sdata->vif.bss_conf.use_short_slot &&
1781             band == IEEE80211_BAND_5GHZ) {
1782                 sdata->vif.bss_conf.use_short_slot = true;
1783                 changed |= BSS_CHANGED_ERP_SLOT;
1784         }
1785
1786         if (params->use_short_slot_time >= 0) {
1787                 sdata->vif.bss_conf.use_short_slot =
1788                         params->use_short_slot_time;
1789                 changed |= BSS_CHANGED_ERP_SLOT;
1790         }
1791
1792         if (params->basic_rates) {
1793                 int i, j;
1794                 u32 rates = 0;
1795                 struct ieee80211_supported_band *sband = wiphy->bands[band];
1796
1797                 for (i = 0; i < params->basic_rates_len; i++) {
1798                         int rate = (params->basic_rates[i] & 0x7f) * 5;
1799                         for (j = 0; j < sband->n_bitrates; j++) {
1800                                 if (sband->bitrates[j].bitrate == rate)
1801                                         rates |= BIT(j);
1802                         }
1803                 }
1804                 sdata->vif.bss_conf.basic_rates = rates;
1805                 changed |= BSS_CHANGED_BASIC_RATES;
1806         }
1807
1808         if (params->ap_isolate >= 0) {
1809                 if (params->ap_isolate)
1810                         sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
1811                 else
1812                         sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
1813         }
1814
1815         if (params->ht_opmode >= 0) {
1816                 sdata->vif.bss_conf.ht_operation_mode =
1817                         (u16) params->ht_opmode;
1818                 changed |= BSS_CHANGED_HT;
1819         }
1820
1821         if (params->p2p_ctwindow >= 0) {
1822                 sdata->vif.bss_conf.p2p_ctwindow = params->p2p_ctwindow;
1823                 changed |= BSS_CHANGED_P2P_PS;
1824         }
1825
1826         if (params->p2p_opp_ps >= 0) {
1827                 sdata->vif.bss_conf.p2p_oppps = params->p2p_opp_ps;
1828                 changed |= BSS_CHANGED_P2P_PS;
1829         }
1830
1831         ieee80211_bss_info_change_notify(sdata, changed);
1832
1833         return 0;
1834 }
1835
1836 static int ieee80211_set_txq_params(struct wiphy *wiphy,
1837                                     struct net_device *dev,
1838                                     struct ieee80211_txq_params *params)
1839 {
1840         struct ieee80211_local *local = wiphy_priv(wiphy);
1841         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1842         struct ieee80211_tx_queue_params p;
1843
1844         if (!local->ops->conf_tx)
1845                 return -EOPNOTSUPP;
1846
1847         if (local->hw.queues < IEEE80211_NUM_ACS)
1848                 return -EOPNOTSUPP;
1849
1850         memset(&p, 0, sizeof(p));
1851         p.aifs = params->aifs;
1852         p.cw_max = params->cwmax;
1853         p.cw_min = params->cwmin;
1854         p.txop = params->txop;
1855
1856         /*
1857          * Setting tx queue params disables u-apsd because it's only
1858          * called in master mode.
1859          */
1860         p.uapsd = false;
1861
1862         sdata->tx_conf[params->ac] = p;
1863         if (drv_conf_tx(local, sdata, params->ac, &p)) {
1864                 wiphy_debug(local->hw.wiphy,
1865                             "failed to set TX queue parameters for AC %d\n",
1866                             params->ac);
1867                 return -EINVAL;
1868         }
1869
1870         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);
1871
1872         return 0;
1873 }
1874
1875 #ifdef CONFIG_PM
1876 static int ieee80211_suspend(struct wiphy *wiphy,
1877                              struct cfg80211_wowlan *wowlan)
1878 {
1879         return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
1880 }
1881
1882 static int ieee80211_resume(struct wiphy *wiphy)
1883 {
1884         return __ieee80211_resume(wiphy_priv(wiphy));
1885 }
1886 #else
1887 #define ieee80211_suspend NULL
1888 #define ieee80211_resume NULL
1889 #endif
1890
1891 static int ieee80211_scan(struct wiphy *wiphy,
1892                           struct cfg80211_scan_request *req)
1893 {
1894         struct ieee80211_sub_if_data *sdata;
1895
1896         sdata = IEEE80211_WDEV_TO_SUB_IF(req->wdev);
1897
1898         switch (ieee80211_vif_type_p2p(&sdata->vif)) {
1899         case NL80211_IFTYPE_STATION:
1900         case NL80211_IFTYPE_ADHOC:
1901         case NL80211_IFTYPE_MESH_POINT:
1902         case NL80211_IFTYPE_P2P_CLIENT:
1903         case NL80211_IFTYPE_P2P_DEVICE:
1904                 break;
1905         case NL80211_IFTYPE_P2P_GO:
1906                 if (sdata->local->ops->hw_scan)
1907                         break;
1908                 /*
1909                  * FIXME: implement NoA while scanning in software,
1910                  * for now fall through to allow scanning only when
1911                  * beaconing hasn't been configured yet
1912                  */
1913         case NL80211_IFTYPE_AP:
1914                 /*
1915                  * If the scan has been forced (and the driver supports
1916                  * forcing), don't care about being beaconing already.
1917                  * This will create problems to the attached stations (e.g. all
1918                  * the  frames sent while scanning on other channel will be
1919                  * lost)
1920                  */
1921                 if (sdata->u.ap.beacon &&
1922                     (!(wiphy->features & NL80211_FEATURE_AP_SCAN) ||
1923                      !(req->flags & NL80211_SCAN_FLAG_AP)))
1924                         return -EOPNOTSUPP;
1925                 break;
1926         default:
1927                 return -EOPNOTSUPP;
1928         }
1929
1930         return ieee80211_request_scan(sdata, req);
1931 }
1932
1933 static int
1934 ieee80211_sched_scan_start(struct wiphy *wiphy,
1935                            struct net_device *dev,
1936                            struct cfg80211_sched_scan_request *req)
1937 {
1938         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1939
1940         if (!sdata->local->ops->sched_scan_start)
1941                 return -EOPNOTSUPP;
1942
1943         return ieee80211_request_sched_scan_start(sdata, req);
1944 }
1945
1946 static int
1947 ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev)
1948 {
1949         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1950
1951         if (!sdata->local->ops->sched_scan_stop)
1952                 return -EOPNOTSUPP;
1953
1954         return ieee80211_request_sched_scan_stop(sdata);
1955 }
1956
1957 static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
1958                           struct cfg80211_auth_request *req)
1959 {
1960         return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
1961 }
1962
1963 static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
1964                            struct cfg80211_assoc_request *req)
1965 {
1966         return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
1967 }
1968
1969 static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
1970                             struct cfg80211_deauth_request *req)
1971 {
1972         return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req);
1973 }
1974
1975 static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
1976                               struct cfg80211_disassoc_request *req)
1977 {
1978         return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
1979 }
1980
1981 static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
1982                                struct cfg80211_ibss_params *params)
1983 {
1984         return ieee80211_ibss_join(IEEE80211_DEV_TO_SUB_IF(dev), params);
1985 }
1986
1987 static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1988 {
1989         return ieee80211_ibss_leave(IEEE80211_DEV_TO_SUB_IF(dev));
1990 }
1991
1992 static int ieee80211_set_mcast_rate(struct wiphy *wiphy, struct net_device *dev,
1993                                     int rate[IEEE80211_NUM_BANDS])
1994 {
1995         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1996
1997         memcpy(sdata->vif.bss_conf.mcast_rate, rate, sizeof(rate));
1998
1999         return 0;
2000 }
2001
2002 static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
2003 {
2004         struct ieee80211_local *local = wiphy_priv(wiphy);
2005         int err;
2006
2007         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
2008                 err = drv_set_frag_threshold(local, wiphy->frag_threshold);
2009
2010                 if (err)
2011                         return err;
2012         }
2013
2014         if (changed & WIPHY_PARAM_COVERAGE_CLASS) {
2015                 err = drv_set_coverage_class(local, wiphy->coverage_class);
2016
2017                 if (err)
2018                         return err;
2019         }
2020
2021         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
2022                 err = drv_set_rts_threshold(local, wiphy->rts_threshold);
2023
2024                 if (err)
2025                         return err;
2026         }
2027
2028         if (changed & WIPHY_PARAM_RETRY_SHORT) {
2029                 if (wiphy->retry_short > IEEE80211_MAX_TX_RETRY)
2030                         return -EINVAL;
2031                 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
2032         }
2033         if (changed & WIPHY_PARAM_RETRY_LONG) {
2034                 if (wiphy->retry_long > IEEE80211_MAX_TX_RETRY)
2035                         return -EINVAL;
2036                 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
2037         }
2038         if (changed &
2039             (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
2040                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
2041
2042         return 0;
2043 }
2044
2045 static int ieee80211_set_tx_power(struct wiphy *wiphy,
2046                                   struct wireless_dev *wdev,
2047                                   enum nl80211_tx_power_setting type, int mbm)
2048 {
2049         struct ieee80211_local *local = wiphy_priv(wiphy);
2050         struct ieee80211_sub_if_data *sdata;
2051
2052         if (wdev) {
2053                 sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2054
2055                 switch (type) {
2056                 case NL80211_TX_POWER_AUTOMATIC:
2057                         sdata->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2058                         break;
2059                 case NL80211_TX_POWER_LIMITED:
2060                 case NL80211_TX_POWER_FIXED:
2061                         if (mbm < 0 || (mbm % 100))
2062                                 return -EOPNOTSUPP;
2063                         sdata->user_power_level = MBM_TO_DBM(mbm);
2064                         break;
2065                 }
2066
2067                 ieee80211_recalc_txpower(sdata);
2068
2069                 return 0;
2070         }
2071
2072         switch (type) {
2073         case NL80211_TX_POWER_AUTOMATIC:
2074                 local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2075                 break;
2076         case NL80211_TX_POWER_LIMITED:
2077         case NL80211_TX_POWER_FIXED:
2078                 if (mbm < 0 || (mbm % 100))
2079                         return -EOPNOTSUPP;
2080                 local->user_power_level = MBM_TO_DBM(mbm);
2081                 break;
2082         }
2083
2084         mutex_lock(&local->iflist_mtx);
2085         list_for_each_entry(sdata, &local->interfaces, list)
2086                 sdata->user_power_level = local->user_power_level;
2087         list_for_each_entry(sdata, &local->interfaces, list)
2088                 ieee80211_recalc_txpower(sdata);
2089         mutex_unlock(&local->iflist_mtx);
2090
2091         return 0;
2092 }
2093
2094 static int ieee80211_get_tx_power(struct wiphy *wiphy,
2095                                   struct wireless_dev *wdev,
2096                                   int *dbm)
2097 {
2098         struct ieee80211_local *local = wiphy_priv(wiphy);
2099         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2100
2101         if (!local->use_chanctx)
2102                 *dbm = local->hw.conf.power_level;
2103         else
2104                 *dbm = sdata->vif.bss_conf.txpower;
2105
2106         return 0;
2107 }
2108
2109 static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
2110                                   const u8 *addr)
2111 {
2112         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2113
2114         memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN);
2115
2116         return 0;
2117 }
2118
2119 static void ieee80211_rfkill_poll(struct wiphy *wiphy)
2120 {
2121         struct ieee80211_local *local = wiphy_priv(wiphy);
2122
2123         drv_rfkill_poll(local);
2124 }
2125
2126 #ifdef CONFIG_NL80211_TESTMODE
2127 static int ieee80211_testmode_cmd(struct wiphy *wiphy, void *data, int len)
2128 {
2129         struct ieee80211_local *local = wiphy_priv(wiphy);
2130
2131         if (!local->ops->testmode_cmd)
2132                 return -EOPNOTSUPP;
2133
2134         return local->ops->testmode_cmd(&local->hw, data, len);
2135 }
2136
2137 static int ieee80211_testmode_dump(struct wiphy *wiphy,
2138                                    struct sk_buff *skb,
2139                                    struct netlink_callback *cb,
2140                                    void *data, int len)
2141 {
2142         struct ieee80211_local *local = wiphy_priv(wiphy);
2143
2144         if (!local->ops->testmode_dump)
2145                 return -EOPNOTSUPP;
2146
2147         return local->ops->testmode_dump(&local->hw, skb, cb, data, len);
2148 }
2149 #endif
2150
2151 int __ieee80211_request_smps(struct ieee80211_sub_if_data *sdata,
2152                              enum ieee80211_smps_mode smps_mode)
2153 {
2154         const u8 *ap;
2155         enum ieee80211_smps_mode old_req;
2156         int err;
2157
2158         lockdep_assert_held(&sdata->u.mgd.mtx);
2159
2160         old_req = sdata->u.mgd.req_smps;
2161         sdata->u.mgd.req_smps = smps_mode;
2162
2163         if (old_req == smps_mode &&
2164             smps_mode != IEEE80211_SMPS_AUTOMATIC)
2165                 return 0;
2166
2167         /*
2168          * If not associated, or current association is not an HT
2169          * association, there's no need to do anything, just store
2170          * the new value until we associate.
2171          */
2172         if (!sdata->u.mgd.associated ||
2173             sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
2174                 return 0;
2175
2176         ap = sdata->u.mgd.associated->bssid;
2177
2178         if (smps_mode == IEEE80211_SMPS_AUTOMATIC) {
2179                 if (sdata->u.mgd.powersave)
2180                         smps_mode = IEEE80211_SMPS_DYNAMIC;
2181                 else
2182                         smps_mode = IEEE80211_SMPS_OFF;
2183         }
2184
2185         /* send SM PS frame to AP */
2186         err = ieee80211_send_smps_action(sdata, smps_mode,
2187                                          ap, ap);
2188         if (err)
2189                 sdata->u.mgd.req_smps = old_req;
2190
2191         return err;
2192 }
2193
2194 static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
2195                                     bool enabled, int timeout)
2196 {
2197         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2198         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2199
2200         if (sdata->vif.type != NL80211_IFTYPE_STATION)
2201                 return -EOPNOTSUPP;
2202
2203         if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
2204                 return -EOPNOTSUPP;
2205
2206         if (enabled == sdata->u.mgd.powersave &&
2207             timeout == local->dynamic_ps_forced_timeout)
2208                 return 0;
2209
2210         sdata->u.mgd.powersave = enabled;
2211         local->dynamic_ps_forced_timeout = timeout;
2212
2213         /* no change, but if automatic follow powersave */
2214         mutex_lock(&sdata->u.mgd.mtx);
2215         __ieee80211_request_smps(sdata, sdata->u.mgd.req_smps);
2216         mutex_unlock(&sdata->u.mgd.mtx);
2217
2218         if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
2219                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
2220
2221         ieee80211_recalc_ps(local, -1);
2222         ieee80211_recalc_ps_vif(sdata);
2223
2224         return 0;
2225 }
2226
2227 static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy,
2228                                          struct net_device *dev,
2229                                          s32 rssi_thold, u32 rssi_hyst)
2230 {
2231         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2232         struct ieee80211_vif *vif = &sdata->vif;
2233         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
2234
2235         if (rssi_thold == bss_conf->cqm_rssi_thold &&
2236             rssi_hyst == bss_conf->cqm_rssi_hyst)
2237                 return 0;
2238
2239         bss_conf->cqm_rssi_thold = rssi_thold;
2240         bss_conf->cqm_rssi_hyst = rssi_hyst;
2241
2242         /* tell the driver upon association, unless already associated */
2243         if (sdata->u.mgd.associated &&
2244             sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
2245                 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);
2246
2247         return 0;
2248 }
2249
2250 static int ieee80211_set_bitrate_mask(struct wiphy *wiphy,
2251                                       struct net_device *dev,
2252                                       const u8 *addr,
2253                                       const struct cfg80211_bitrate_mask *mask)
2254 {
2255         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2256         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2257         int i, ret;
2258
2259         if (!ieee80211_sdata_running(sdata))
2260                 return -ENETDOWN;
2261
2262         if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
2263                 ret = drv_set_bitrate_mask(local, sdata, mask);
2264                 if (ret)
2265                         return ret;
2266         }
2267
2268         for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
2269                 sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
2270                 memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].mcs,
2271                        sizeof(mask->control[i].mcs));
2272         }
2273
2274         return 0;
2275 }
2276
2277 static int ieee80211_start_roc_work(struct ieee80211_local *local,
2278                                     struct ieee80211_sub_if_data *sdata,
2279                                     struct ieee80211_channel *channel,
2280                                     unsigned int duration, u64 *cookie,
2281                                     struct sk_buff *txskb)
2282 {
2283         struct ieee80211_roc_work *roc, *tmp;
2284         bool queued = false;
2285         int ret;
2286
2287         lockdep_assert_held(&local->mtx);
2288
2289         if (local->use_chanctx && !local->ops->remain_on_channel)
2290                 return -EOPNOTSUPP;
2291
2292         roc = kzalloc(sizeof(*roc), GFP_KERNEL);
2293         if (!roc)
2294                 return -ENOMEM;
2295
2296         roc->chan = channel;
2297         roc->duration = duration;
2298         roc->req_duration = duration;
2299         roc->frame = txskb;
2300         roc->mgmt_tx_cookie = (unsigned long)txskb;
2301         roc->sdata = sdata;
2302         INIT_DELAYED_WORK(&roc->work, ieee80211_sw_roc_work);
2303         INIT_LIST_HEAD(&roc->dependents);
2304
2305         /* if there's one pending or we're scanning, queue this one */
2306         if (!list_empty(&local->roc_list) || local->scanning)
2307                 goto out_check_combine;
2308
2309         /* if not HW assist, just queue & schedule work */
2310         if (!local->ops->remain_on_channel) {
2311                 ieee80211_queue_delayed_work(&local->hw, &roc->work, 0);
2312                 goto out_queue;
2313         }
2314
2315         /* otherwise actually kick it off here (for error handling) */
2316
2317         /*
2318          * If the duration is zero, then the driver
2319          * wouldn't actually do anything. Set it to
2320          * 10 for now.
2321          *
2322          * TODO: cancel the off-channel operation
2323          *       when we get the SKB's TX status and
2324          *       the wait time was zero before.
2325          */
2326         if (!duration)
2327                 duration = 10;
2328
2329         ret = drv_remain_on_channel(local, sdata, channel, duration);
2330         if (ret) {
2331                 kfree(roc);
2332                 return ret;
2333         }
2334
2335         roc->started = true;
2336         goto out_queue;
2337
2338  out_check_combine:
2339         list_for_each_entry(tmp, &local->roc_list, list) {
2340                 if (tmp->chan != channel || tmp->sdata != sdata)
2341                         continue;
2342
2343                 /*
2344                  * Extend this ROC if possible:
2345                  *
2346                  * If it hasn't started yet, just increase the duration
2347                  * and add the new one to the list of dependents.
2348                  */
2349                 if (!tmp->started) {
2350                         list_add_tail(&roc->list, &tmp->dependents);
2351                         tmp->duration = max(tmp->duration, roc->duration);
2352                         queued = true;
2353                         break;
2354                 }
2355
2356                 /* If it has already started, it's more difficult ... */
2357                 if (local->ops->remain_on_channel) {
2358                         unsigned long j = jiffies;
2359
2360                         /*
2361                          * In the offloaded ROC case, if it hasn't begun, add
2362                          * this new one to the dependent list to be handled
2363                          * when the the master one begins. If it has begun,
2364                          * check that there's still a minimum time left and
2365                          * if so, start this one, transmitting the frame, but
2366                          * add it to the list directly after this one with a
2367                          * a reduced time so we'll ask the driver to execute
2368                          * it right after finishing the previous one, in the
2369                          * hope that it'll also be executed right afterwards,
2370                          * effectively extending the old one.
2371                          * If there's no minimum time left, just add it to the
2372                          * normal list.
2373                          */
2374                         if (!tmp->hw_begun) {
2375                                 list_add_tail(&roc->list, &tmp->dependents);
2376                                 queued = true;
2377                                 break;
2378                         }
2379
2380                         if (time_before(j + IEEE80211_ROC_MIN_LEFT,
2381                                         tmp->hw_start_time +
2382                                         msecs_to_jiffies(tmp->duration))) {
2383                                 int new_dur;
2384
2385                                 ieee80211_handle_roc_started(roc);
2386
2387                                 new_dur = roc->duration -
2388                                           jiffies_to_msecs(tmp->hw_start_time +
2389                                                            msecs_to_jiffies(
2390                                                                 tmp->duration) -
2391                                                            j);
2392
2393                                 if (new_dur > 0) {
2394                                         /* add right after tmp */
2395                                         list_add(&roc->list, &tmp->list);
2396                                 } else {
2397                                         list_add_tail(&roc->list,
2398                                                       &tmp->dependents);
2399                                 }
2400                                 queued = true;
2401                         }
2402                 } else if (del_timer_sync(&tmp->work.timer)) {
2403                         unsigned long new_end;
2404
2405                         /*
2406                          * In the software ROC case, cancel the timer, if
2407                          * that fails then the finish work is already
2408                          * queued/pending and thus we queue the new ROC
2409                          * normally, if that succeeds then we can extend
2410                          * the timer duration and TX the frame (if any.)
2411                          */
2412
2413                         list_add_tail(&roc->list, &tmp->dependents);
2414                         queued = true;
2415
2416                         new_end = jiffies + msecs_to_jiffies(roc->duration);
2417
2418                         /* ok, it was started & we canceled timer */
2419                         if (time_after(new_end, tmp->work.timer.expires))
2420                                 mod_timer(&tmp->work.timer, new_end);
2421                         else
2422                                 add_timer(&tmp->work.timer);
2423
2424                         ieee80211_handle_roc_started(roc);
2425                 }
2426                 break;
2427         }
2428
2429  out_queue:
2430         if (!queued)
2431                 list_add_tail(&roc->list, &local->roc_list);
2432
2433         /*
2434          * cookie is either the roc cookie (for normal roc)
2435          * or the SKB (for mgmt TX)
2436          */
2437         if (!txskb) {
2438                 /* local->mtx protects this */
2439                 local->roc_cookie_counter++;
2440                 roc->cookie = local->roc_cookie_counter;
2441                 /* wow, you wrapped 64 bits ... more likely a bug */
2442                 if (WARN_ON(roc->cookie == 0)) {
2443                         roc->cookie = 1;
2444                         local->roc_cookie_counter++;
2445                 }
2446                 *cookie = roc->cookie;
2447         } else {
2448                 *cookie = (unsigned long)txskb;
2449         }
2450
2451         return 0;
2452 }
2453
2454 static int ieee80211_remain_on_channel(struct wiphy *wiphy,
2455                                        struct wireless_dev *wdev,
2456                                        struct ieee80211_channel *chan,
2457                                        unsigned int duration,
2458                                        u64 *cookie)
2459 {
2460         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2461         struct ieee80211_local *local = sdata->local;
2462         int ret;
2463
2464         mutex_lock(&local->mtx);
2465         ret = ieee80211_start_roc_work(local, sdata, chan,
2466                                        duration, cookie, NULL);
2467         mutex_unlock(&local->mtx);
2468
2469         return ret;
2470 }
2471
2472 static int ieee80211_cancel_roc(struct ieee80211_local *local,
2473                                 u64 cookie, bool mgmt_tx)
2474 {
2475         struct ieee80211_roc_work *roc, *tmp, *found = NULL;
2476         int ret;
2477
2478         mutex_lock(&local->mtx);
2479         list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
2480                 struct ieee80211_roc_work *dep, *tmp2;
2481
2482                 list_for_each_entry_safe(dep, tmp2, &roc->dependents, list) {
2483                         if (!mgmt_tx && dep->cookie != cookie)
2484                                 continue;
2485                         else if (mgmt_tx && dep->mgmt_tx_cookie != cookie)
2486                                 continue;
2487                         /* found dependent item -- just remove it */
2488                         list_del(&dep->list);
2489                         mutex_unlock(&local->mtx);
2490
2491                         ieee80211_roc_notify_destroy(dep);
2492                         return 0;
2493                 }
2494
2495                 if (!mgmt_tx && roc->cookie != cookie)
2496                         continue;
2497                 else if (mgmt_tx && roc->mgmt_tx_cookie != cookie)
2498                         continue;
2499
2500                 found = roc;
2501                 break;
2502         }
2503
2504         if (!found) {
2505                 mutex_unlock(&local->mtx);
2506                 return -ENOENT;
2507         }
2508
2509         /*
2510          * We found the item to cancel, so do that. Note that it
2511          * may have dependents, which we also cancel (and send
2512          * the expired signal for.) Not doing so would be quite
2513          * tricky here, but we may need to fix it later.
2514          */
2515
2516         if (local->ops->remain_on_channel) {
2517                 if (found->started) {
2518                         ret = drv_cancel_remain_on_channel(local);
2519                         if (WARN_ON_ONCE(ret)) {
2520                                 mutex_unlock(&local->mtx);
2521                                 return ret;
2522                         }
2523                 }
2524
2525                 list_del(&found->list);
2526
2527                 if (found->started)
2528                         ieee80211_start_next_roc(local);
2529                 mutex_unlock(&local->mtx);
2530
2531                 ieee80211_roc_notify_destroy(found);
2532         } else {
2533                 /* work may be pending so use it all the time */
2534                 found->abort = true;
2535                 ieee80211_queue_delayed_work(&local->hw, &found->work, 0);
2536
2537                 mutex_unlock(&local->mtx);
2538
2539                 /* work will clean up etc */
2540                 flush_delayed_work(&found->work);
2541         }
2542
2543         return 0;
2544 }
2545
2546 static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
2547                                               struct wireless_dev *wdev,
2548                                               u64 cookie)
2549 {
2550         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2551         struct ieee80211_local *local = sdata->local;
2552
2553         return ieee80211_cancel_roc(local, cookie, false);
2554 }
2555
2556 static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
2557                              struct ieee80211_channel *chan, bool offchan,
2558                              unsigned int wait, const u8 *buf, size_t len,
2559                              bool no_cck, bool dont_wait_for_ack, u64 *cookie)
2560 {
2561         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2562         struct ieee80211_local *local = sdata->local;
2563         struct sk_buff *skb;
2564         struct sta_info *sta;
2565         const struct ieee80211_mgmt *mgmt = (void *)buf;
2566         bool need_offchan = false;
2567         u32 flags;
2568         int ret;
2569
2570         if (dont_wait_for_ack)
2571                 flags = IEEE80211_TX_CTL_NO_ACK;
2572         else
2573                 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
2574                         IEEE80211_TX_CTL_REQ_TX_STATUS;
2575
2576         if (no_cck)
2577                 flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
2578
2579         switch (sdata->vif.type) {
2580         case NL80211_IFTYPE_ADHOC:
2581                 if (!sdata->vif.bss_conf.ibss_joined)
2582                         need_offchan = true;
2583                 /* fall through */
2584 #ifdef CONFIG_MAC80211_MESH
2585         case NL80211_IFTYPE_MESH_POINT:
2586                 if (ieee80211_vif_is_mesh(&sdata->vif) &&
2587                     !sdata->u.mesh.mesh_id_len)
2588                         need_offchan = true;
2589                 /* fall through */
2590 #endif
2591         case NL80211_IFTYPE_AP:
2592         case NL80211_IFTYPE_AP_VLAN:
2593         case NL80211_IFTYPE_P2P_GO:
2594                 if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
2595                     !ieee80211_vif_is_mesh(&sdata->vif) &&
2596                     !rcu_access_pointer(sdata->bss->beacon))
2597                         need_offchan = true;
2598                 if (!ieee80211_is_action(mgmt->frame_control) ||
2599                     mgmt->u.action.category == WLAN_CATEGORY_PUBLIC)
2600                         break;
2601                 rcu_read_lock();
2602                 sta = sta_info_get(sdata, mgmt->da);
2603                 rcu_read_unlock();
2604                 if (!sta)
2605                         return -ENOLINK;
2606                 break;
2607         case NL80211_IFTYPE_STATION:
2608         case NL80211_IFTYPE_P2P_CLIENT:
2609                 if (!sdata->u.mgd.associated)
2610                         need_offchan = true;
2611                 break;
2612         case NL80211_IFTYPE_P2P_DEVICE:
2613                 need_offchan = true;
2614                 break;
2615         default:
2616                 return -EOPNOTSUPP;
2617         }
2618
2619         mutex_lock(&local->mtx);
2620
2621         /* Check if the operating channel is the requested channel */
2622         if (!need_offchan) {
2623                 struct ieee80211_chanctx_conf *chanctx_conf;
2624
2625                 rcu_read_lock();
2626                 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
2627
2628                 if (chanctx_conf)
2629                         need_offchan = chan != chanctx_conf->def.chan;
2630                 else
2631                         need_offchan = true;
2632                 rcu_read_unlock();
2633         }
2634
2635         if (need_offchan && !offchan) {
2636                 ret = -EBUSY;
2637                 goto out_unlock;
2638         }
2639
2640         skb = dev_alloc_skb(local->hw.extra_tx_headroom + len);
2641         if (!skb) {
2642                 ret = -ENOMEM;
2643                 goto out_unlock;
2644         }
2645         skb_reserve(skb, local->hw.extra_tx_headroom);
2646
2647         memcpy(skb_put(skb, len), buf, len);
2648
2649         IEEE80211_SKB_CB(skb)->flags = flags;
2650
2651         skb->dev = sdata->dev;
2652
2653         if (!need_offchan) {
2654                 *cookie = (unsigned long) skb;
2655                 ieee80211_tx_skb(sdata, skb);
2656                 ret = 0;
2657                 goto out_unlock;
2658         }
2659
2660         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN;
2661         if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
2662                 IEEE80211_SKB_CB(skb)->hw_queue =
2663                         local->hw.offchannel_tx_hw_queue;
2664
2665         /* This will handle all kinds of coalescing and immediate TX */
2666         ret = ieee80211_start_roc_work(local, sdata, chan,
2667                                        wait, cookie, skb);
2668         if (ret)
2669                 kfree_skb(skb);
2670  out_unlock:
2671         mutex_unlock(&local->mtx);
2672         return ret;
2673 }
2674
2675 static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
2676                                          struct wireless_dev *wdev,
2677                                          u64 cookie)
2678 {
2679         struct ieee80211_local *local = wiphy_priv(wiphy);
2680
2681         return ieee80211_cancel_roc(local, cookie, true);
2682 }
2683
2684 static void ieee80211_mgmt_frame_register(struct wiphy *wiphy,
2685                                           struct wireless_dev *wdev,
2686                                           u16 frame_type, bool reg)
2687 {
2688         struct ieee80211_local *local = wiphy_priv(wiphy);
2689         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2690
2691         switch (frame_type) {
2692         case IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH:
2693                 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
2694                         struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
2695
2696                         if (reg)
2697                                 ifibss->auth_frame_registrations++;
2698                         else
2699                                 ifibss->auth_frame_registrations--;
2700                 }
2701                 break;
2702         case IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ:
2703                 if (reg)
2704                         local->probe_req_reg++;
2705                 else
2706                         local->probe_req_reg--;
2707
2708                 if (!local->open_count)
2709                         break;
2710
2711                 ieee80211_queue_work(&local->hw, &local->reconfig_filter);
2712                 break;
2713         default:
2714                 break;
2715         }
2716 }
2717
2718 static int ieee80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
2719 {
2720         struct ieee80211_local *local = wiphy_priv(wiphy);
2721
2722         if (local->started)
2723                 return -EOPNOTSUPP;
2724
2725         return drv_set_antenna(local, tx_ant, rx_ant);
2726 }
2727
2728 static int ieee80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant)
2729 {
2730         struct ieee80211_local *local = wiphy_priv(wiphy);
2731
2732         return drv_get_antenna(local, tx_ant, rx_ant);
2733 }
2734
2735 static int ieee80211_set_ringparam(struct wiphy *wiphy, u32 tx, u32 rx)
2736 {
2737         struct ieee80211_local *local = wiphy_priv(wiphy);
2738
2739         return drv_set_ringparam(local, tx, rx);
2740 }
2741
2742 static void ieee80211_get_ringparam(struct wiphy *wiphy,
2743                                     u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
2744 {
2745         struct ieee80211_local *local = wiphy_priv(wiphy);
2746
2747         drv_get_ringparam(local, tx, tx_max, rx, rx_max);
2748 }
2749
2750 static int ieee80211_set_rekey_data(struct wiphy *wiphy,
2751                                     struct net_device *dev,
2752                                     struct cfg80211_gtk_rekey_data *data)
2753 {
2754         struct ieee80211_local *local = wiphy_priv(wiphy);
2755         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2756
2757         if (!local->ops->set_rekey_data)
2758                 return -EOPNOTSUPP;
2759
2760         drv_set_rekey_data(local, sdata, data);
2761
2762         return 0;
2763 }
2764
2765 static void ieee80211_tdls_add_ext_capab(struct sk_buff *skb)
2766 {
2767         u8 *pos = (void *)skb_put(skb, 7);
2768
2769         *pos++ = WLAN_EID_EXT_CAPABILITY;
2770         *pos++ = 5; /* len */
2771         *pos++ = 0x0;
2772         *pos++ = 0x0;
2773         *pos++ = 0x0;
2774         *pos++ = 0x0;
2775         *pos++ = WLAN_EXT_CAPA5_TDLS_ENABLED;
2776 }
2777
2778 static u16 ieee80211_get_tdls_sta_capab(struct ieee80211_sub_if_data *sdata)
2779 {
2780         struct ieee80211_local *local = sdata->local;
2781         u16 capab;
2782
2783         capab = 0;
2784         if (ieee80211_get_sdata_band(sdata) != IEEE80211_BAND_2GHZ)
2785                 return capab;
2786
2787         if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
2788                 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
2789         if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
2790                 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
2791
2792         return capab;
2793 }
2794
2795 static void ieee80211_tdls_add_link_ie(struct sk_buff *skb, u8 *src_addr,
2796                                        u8 *peer, u8 *bssid)
2797 {
2798         struct ieee80211_tdls_lnkie *lnkid;
2799
2800         lnkid = (void *)skb_put(skb, sizeof(struct ieee80211_tdls_lnkie));
2801
2802         lnkid->ie_type = WLAN_EID_LINK_ID;
2803         lnkid->ie_len = sizeof(struct ieee80211_tdls_lnkie) - 2;
2804
2805         memcpy(lnkid->bssid, bssid, ETH_ALEN);
2806         memcpy(lnkid->init_sta, src_addr, ETH_ALEN);
2807         memcpy(lnkid->resp_sta, peer, ETH_ALEN);
2808 }
2809
2810 static int
2811 ieee80211_prep_tdls_encap_data(struct wiphy *wiphy, struct net_device *dev,
2812                                u8 *peer, u8 action_code, u8 dialog_token,
2813                                u16 status_code, struct sk_buff *skb)
2814 {
2815         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2816         enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
2817         struct ieee80211_tdls_data *tf;
2818
2819         tf = (void *)skb_put(skb, offsetof(struct ieee80211_tdls_data, u));
2820
2821         memcpy(tf->da, peer, ETH_ALEN);
2822         memcpy(tf->sa, sdata->vif.addr, ETH_ALEN);
2823         tf->ether_type = cpu_to_be16(ETH_P_TDLS);
2824         tf->payload_type = WLAN_TDLS_SNAP_RFTYPE;
2825
2826         switch (action_code) {
2827         case WLAN_TDLS_SETUP_REQUEST:
2828                 tf->category = WLAN_CATEGORY_TDLS;
2829                 tf->action_code = WLAN_TDLS_SETUP_REQUEST;
2830
2831                 skb_put(skb, sizeof(tf->u.setup_req));
2832                 tf->u.setup_req.dialog_token = dialog_token;
2833                 tf->u.setup_req.capability =
2834                         cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
2835
2836                 ieee80211_add_srates_ie(sdata, skb, false, band);
2837                 ieee80211_add_ext_srates_ie(sdata, skb, false, band);
2838                 ieee80211_tdls_add_ext_capab(skb);
2839                 break;
2840         case WLAN_TDLS_SETUP_RESPONSE:
2841                 tf->category = WLAN_CATEGORY_TDLS;
2842                 tf->action_code = WLAN_TDLS_SETUP_RESPONSE;
2843
2844                 skb_put(skb, sizeof(tf->u.setup_resp));
2845                 tf->u.setup_resp.status_code = cpu_to_le16(status_code);
2846                 tf->u.setup_resp.dialog_token = dialog_token;
2847                 tf->u.setup_resp.capability =
2848                         cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
2849
2850                 ieee80211_add_srates_ie(sdata, skb, false, band);
2851                 ieee80211_add_ext_srates_ie(sdata, skb, false, band);
2852                 ieee80211_tdls_add_ext_capab(skb);
2853                 break;
2854         case WLAN_TDLS_SETUP_CONFIRM:
2855                 tf->category = WLAN_CATEGORY_TDLS;
2856                 tf->action_code = WLAN_TDLS_SETUP_CONFIRM;
2857
2858                 skb_put(skb, sizeof(tf->u.setup_cfm));
2859                 tf->u.setup_cfm.status_code = cpu_to_le16(status_code);
2860                 tf->u.setup_cfm.dialog_token = dialog_token;
2861                 break;
2862         case WLAN_TDLS_TEARDOWN:
2863                 tf->category = WLAN_CATEGORY_TDLS;
2864                 tf->action_code = WLAN_TDLS_TEARDOWN;
2865
2866                 skb_put(skb, sizeof(tf->u.teardown));
2867                 tf->u.teardown.reason_code = cpu_to_le16(status_code);
2868                 break;
2869         case WLAN_TDLS_DISCOVERY_REQUEST:
2870                 tf->category = WLAN_CATEGORY_TDLS;
2871                 tf->action_code = WLAN_TDLS_DISCOVERY_REQUEST;
2872
2873                 skb_put(skb, sizeof(tf->u.discover_req));
2874                 tf->u.discover_req.dialog_token = dialog_token;
2875                 break;
2876         default:
2877                 return -EINVAL;
2878         }
2879
2880         return 0;
2881 }
2882
2883 static int
2884 ieee80211_prep_tdls_direct(struct wiphy *wiphy, struct net_device *dev,
2885                            u8 *peer, u8 action_code, u8 dialog_token,
2886                            u16 status_code, struct sk_buff *skb)
2887 {
2888         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2889         enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
2890         struct ieee80211_mgmt *mgmt;
2891
2892         mgmt = (void *)skb_put(skb, 24);
2893         memset(mgmt, 0, 24);
2894         memcpy(mgmt->da, peer, ETH_ALEN);
2895         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
2896         memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
2897
2898         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2899                                           IEEE80211_STYPE_ACTION);
2900
2901         switch (action_code) {
2902         case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
2903                 skb_put(skb, 1 + sizeof(mgmt->u.action.u.tdls_discover_resp));
2904                 mgmt->u.action.category = WLAN_CATEGORY_PUBLIC;
2905                 mgmt->u.action.u.tdls_discover_resp.action_code =
2906                         WLAN_PUB_ACTION_TDLS_DISCOVER_RES;
2907                 mgmt->u.action.u.tdls_discover_resp.dialog_token =
2908                         dialog_token;
2909                 mgmt->u.action.u.tdls_discover_resp.capability =
2910                         cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
2911
2912                 ieee80211_add_srates_ie(sdata, skb, false, band);
2913                 ieee80211_add_ext_srates_ie(sdata, skb, false, band);
2914                 ieee80211_tdls_add_ext_capab(skb);
2915                 break;
2916         default:
2917                 return -EINVAL;
2918         }
2919
2920         return 0;
2921 }
2922
2923 static int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
2924                                u8 *peer, u8 action_code, u8 dialog_token,
2925                                u16 status_code, const u8 *extra_ies,
2926                                size_t extra_ies_len)
2927 {
2928         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2929         struct ieee80211_local *local = sdata->local;
2930         struct sk_buff *skb = NULL;
2931         bool send_direct;
2932         int ret;
2933
2934         if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
2935                 return -ENOTSUPP;
2936
2937         /* make sure we are in managed mode, and associated */
2938         if (sdata->vif.type != NL80211_IFTYPE_STATION ||
2939             !sdata->u.mgd.associated)
2940                 return -EINVAL;
2941
2942         tdls_dbg(sdata, "TDLS mgmt action %d peer %pM\n",
2943                  action_code, peer);
2944
2945         skb = dev_alloc_skb(local->hw.extra_tx_headroom +
2946                             max(sizeof(struct ieee80211_mgmt),
2947                                 sizeof(struct ieee80211_tdls_data)) +
2948                             50 + /* supported rates */
2949                             7 + /* ext capab */
2950                             extra_ies_len +
2951                             sizeof(struct ieee80211_tdls_lnkie));
2952         if (!skb)
2953                 return -ENOMEM;
2954
2955         skb_reserve(skb, local->hw.extra_tx_headroom);
2956
2957         switch (action_code) {
2958         case WLAN_TDLS_SETUP_REQUEST:
2959         case WLAN_TDLS_SETUP_RESPONSE:
2960         case WLAN_TDLS_SETUP_CONFIRM:
2961         case WLAN_TDLS_TEARDOWN:
2962         case WLAN_TDLS_DISCOVERY_REQUEST:
2963                 ret = ieee80211_prep_tdls_encap_data(wiphy, dev, peer,
2964                                                      action_code, dialog_token,
2965                                                      status_code, skb);
2966                 send_direct = false;
2967                 break;
2968         case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
2969                 ret = ieee80211_prep_tdls_direct(wiphy, dev, peer, action_code,
2970                                                  dialog_token, status_code,
2971                                                  skb);
2972                 send_direct = true;
2973                 break;
2974         default:
2975                 ret = -ENOTSUPP;
2976                 break;
2977         }
2978
2979         if (ret < 0)
2980                 goto fail;
2981
2982         if (extra_ies_len)
2983                 memcpy(skb_put(skb, extra_ies_len), extra_ies, extra_ies_len);
2984
2985         /* the TDLS link IE is always added last */
2986         switch (action_code) {
2987         case WLAN_TDLS_SETUP_REQUEST:
2988         case WLAN_TDLS_SETUP_CONFIRM:
2989         case WLAN_TDLS_TEARDOWN:
2990         case WLAN_TDLS_DISCOVERY_REQUEST:
2991                 /* we are the initiator */
2992                 ieee80211_tdls_add_link_ie(skb, sdata->vif.addr, peer,
2993                                            sdata->u.mgd.bssid);
2994                 break;
2995         case WLAN_TDLS_SETUP_RESPONSE:
2996         case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
2997                 /* we are the responder */
2998                 ieee80211_tdls_add_link_ie(skb, peer, sdata->vif.addr,
2999                                            sdata->u.mgd.bssid);
3000                 break;
3001         default:
3002                 ret = -ENOTSUPP;
3003                 goto fail;
3004         }
3005
3006         if (send_direct) {
3007                 ieee80211_tx_skb(sdata, skb);
3008                 return 0;
3009         }
3010
3011         /*
3012          * According to 802.11z: Setup req/resp are sent in AC_BK, otherwise
3013          * we should default to AC_VI.
3014          */
3015         switch (action_code) {
3016         case WLAN_TDLS_SETUP_REQUEST:
3017         case WLAN_TDLS_SETUP_RESPONSE:
3018                 skb_set_queue_mapping(skb, IEEE80211_AC_BK);
3019                 skb->priority = 2;
3020                 break;
3021         default:
3022                 skb_set_queue_mapping(skb, IEEE80211_AC_VI);
3023                 skb->priority = 5;
3024                 break;
3025         }
3026
3027         /* disable bottom halves when entering the Tx path */
3028         local_bh_disable();
3029         ret = ieee80211_subif_start_xmit(skb, dev);
3030         local_bh_enable();
3031
3032         return ret;
3033
3034 fail:
3035         dev_kfree_skb(skb);
3036         return ret;
3037 }
3038
3039 static int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
3040                                u8 *peer, enum nl80211_tdls_operation oper)
3041 {
3042         struct sta_info *sta;
3043         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3044
3045         if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
3046                 return -ENOTSUPP;
3047
3048         if (sdata->vif.type != NL80211_IFTYPE_STATION)
3049                 return -EINVAL;
3050
3051         tdls_dbg(sdata, "TDLS oper %d peer %pM\n", oper, peer);
3052
3053         switch (oper) {
3054         case NL80211_TDLS_ENABLE_LINK:
3055                 rcu_read_lock();
3056                 sta = sta_info_get(sdata, peer);
3057                 if (!sta) {
3058                         rcu_read_unlock();
3059                         return -ENOLINK;
3060                 }
3061
3062                 set_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH);
3063                 rcu_read_unlock();
3064                 break;
3065         case NL80211_TDLS_DISABLE_LINK:
3066                 return sta_info_destroy_addr(sdata, peer);
3067         case NL80211_TDLS_TEARDOWN:
3068         case NL80211_TDLS_SETUP:
3069         case NL80211_TDLS_DISCOVERY_REQ:
3070                 /* We don't support in-driver setup/teardown/discovery */
3071                 return -ENOTSUPP;
3072         default:
3073                 return -ENOTSUPP;
3074         }
3075
3076         return 0;
3077 }
3078
3079 static int ieee80211_probe_client(struct wiphy *wiphy, struct net_device *dev,
3080                                   const u8 *peer, u64 *cookie)
3081 {
3082         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3083         struct ieee80211_local *local = sdata->local;
3084         struct ieee80211_qos_hdr *nullfunc;
3085         struct sk_buff *skb;
3086         int size = sizeof(*nullfunc);
3087         __le16 fc;
3088         bool qos;
3089         struct ieee80211_tx_info *info;
3090         struct sta_info *sta;
3091         struct ieee80211_chanctx_conf *chanctx_conf;
3092         enum ieee80211_band band;
3093
3094         rcu_read_lock();
3095         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3096         if (WARN_ON(!chanctx_conf)) {
3097                 rcu_read_unlock();
3098                 return -EINVAL;
3099         }
3100         band = chanctx_conf->def.chan->band;
3101         sta = sta_info_get(sdata, peer);
3102         if (sta) {
3103                 qos = test_sta_flag(sta, WLAN_STA_WME);
3104         } else {
3105                 rcu_read_unlock();
3106                 return -ENOLINK;
3107         }
3108
3109         if (qos) {
3110                 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
3111                                  IEEE80211_STYPE_QOS_NULLFUNC |
3112                                  IEEE80211_FCTL_FROMDS);
3113         } else {
3114                 size -= 2;
3115                 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
3116                                  IEEE80211_STYPE_NULLFUNC |
3117                                  IEEE80211_FCTL_FROMDS);
3118         }
3119
3120         skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
3121         if (!skb) {
3122                 rcu_read_unlock();
3123                 return -ENOMEM;
3124         }
3125
3126         skb->dev = dev;
3127
3128         skb_reserve(skb, local->hw.extra_tx_headroom);
3129
3130         nullfunc = (void *) skb_put(skb, size);
3131         nullfunc->frame_control = fc;
3132         nullfunc->duration_id = 0;
3133         memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
3134         memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
3135         memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
3136         nullfunc->seq_ctrl = 0;
3137
3138         info = IEEE80211_SKB_CB(skb);
3139
3140         info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS |
3141                        IEEE80211_TX_INTFL_NL80211_FRAME_TX;
3142
3143         skb_set_queue_mapping(skb, IEEE80211_AC_VO);
3144         skb->priority = 7;
3145         if (qos)
3146                 nullfunc->qos_ctrl = cpu_to_le16(7);
3147
3148         local_bh_disable();
3149         ieee80211_xmit(sdata, skb, band);
3150         local_bh_enable();
3151         rcu_read_unlock();
3152
3153         *cookie = (unsigned long) skb;
3154         return 0;
3155 }
3156
3157 static int ieee80211_cfg_get_channel(struct wiphy *wiphy,
3158                                      struct wireless_dev *wdev,
3159                                      struct cfg80211_chan_def *chandef)
3160 {
3161         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3162         struct ieee80211_chanctx_conf *chanctx_conf;
3163         int ret = -ENODATA;
3164
3165         rcu_read_lock();
3166         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3167         if (chanctx_conf) {
3168                 *chandef = chanctx_conf->def;
3169                 ret = 0;
3170         }
3171         rcu_read_unlock();
3172
3173         return ret;
3174 }
3175
3176 #ifdef CONFIG_PM
3177 static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
3178 {
3179         drv_set_wakeup(wiphy_priv(wiphy), enabled);
3180 }
3181 #endif
3182
3183 struct cfg80211_ops mac80211_config_ops = {
3184         .add_virtual_intf = ieee80211_add_iface,
3185         .del_virtual_intf = ieee80211_del_iface,
3186         .change_virtual_intf = ieee80211_change_iface,
3187         .start_p2p_device = ieee80211_start_p2p_device,
3188         .stop_p2p_device = ieee80211_stop_p2p_device,
3189         .add_key = ieee80211_add_key,
3190         .del_key = ieee80211_del_key,
3191         .get_key = ieee80211_get_key,
3192         .set_default_key = ieee80211_config_default_key,
3193         .set_default_mgmt_key = ieee80211_config_default_mgmt_key,
3194         .start_ap = ieee80211_start_ap,
3195         .change_beacon = ieee80211_change_beacon,
3196         .stop_ap = ieee80211_stop_ap,
3197         .add_station = ieee80211_add_station,
3198         .del_station = ieee80211_del_station,
3199         .change_station = ieee80211_change_station,
3200         .get_station = ieee80211_get_station,
3201         .dump_station = ieee80211_dump_station,
3202         .dump_survey = ieee80211_dump_survey,
3203 #ifdef CONFIG_MAC80211_MESH
3204         .add_mpath = ieee80211_add_mpath,
3205         .del_mpath = ieee80211_del_mpath,
3206         .change_mpath = ieee80211_change_mpath,
3207         .get_mpath = ieee80211_get_mpath,
3208         .dump_mpath = ieee80211_dump_mpath,
3209         .update_mesh_config = ieee80211_update_mesh_config,
3210         .get_mesh_config = ieee80211_get_mesh_config,
3211         .join_mesh = ieee80211_join_mesh,
3212         .leave_mesh = ieee80211_leave_mesh,
3213 #endif
3214         .change_bss = ieee80211_change_bss,
3215         .set_txq_params = ieee80211_set_txq_params,
3216         .set_monitor_channel = ieee80211_set_monitor_channel,
3217         .suspend = ieee80211_suspend,
3218         .resume = ieee80211_resume,
3219         .scan = ieee80211_scan,
3220         .sched_scan_start = ieee80211_sched_scan_start,
3221         .sched_scan_stop = ieee80211_sched_scan_stop,
3222         .auth = ieee80211_auth,
3223         .assoc = ieee80211_assoc,
3224         .deauth = ieee80211_deauth,
3225         .disassoc = ieee80211_disassoc,
3226         .join_ibss = ieee80211_join_ibss,
3227         .leave_ibss = ieee80211_leave_ibss,
3228         .set_mcast_rate = ieee80211_set_mcast_rate,
3229         .set_wiphy_params = ieee80211_set_wiphy_params,
3230         .set_tx_power = ieee80211_set_tx_power,
3231         .get_tx_power = ieee80211_get_tx_power,
3232         .set_wds_peer = ieee80211_set_wds_peer,
3233         .rfkill_poll = ieee80211_rfkill_poll,
3234         CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
3235         CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
3236         .set_power_mgmt = ieee80211_set_power_mgmt,
3237         .set_bitrate_mask = ieee80211_set_bitrate_mask,
3238         .remain_on_channel = ieee80211_remain_on_channel,
3239         .cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
3240         .mgmt_tx = ieee80211_mgmt_tx,
3241         .mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
3242         .set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
3243         .mgmt_frame_register = ieee80211_mgmt_frame_register,
3244         .set_antenna = ieee80211_set_antenna,
3245         .get_antenna = ieee80211_get_antenna,
3246         .set_ringparam = ieee80211_set_ringparam,
3247         .get_ringparam = ieee80211_get_ringparam,
3248         .set_rekey_data = ieee80211_set_rekey_data,
3249         .tdls_oper = ieee80211_tdls_oper,
3250         .tdls_mgmt = ieee80211_tdls_mgmt,
3251         .probe_client = ieee80211_probe_client,
3252         .set_noack_map = ieee80211_set_noack_map,
3253 #ifdef CONFIG_PM
3254         .set_wakeup = ieee80211_set_wakeup,
3255 #endif
3256         .get_et_sset_count = ieee80211_get_et_sset_count,
3257         .get_et_stats = ieee80211_get_et_stats,
3258         .get_et_strings = ieee80211_get_et_strings,
3259         .get_channel = ieee80211_cfg_get_channel,
3260 };