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