← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-backports-modules-3.5.0/quantal-updates

« back to all changes in this revision

Viewing changes to updates/cw-3.6/net/mac80211/cfg.c

  • Committer: Package Import Robot
  • Author(s): Leann Ogasawara
  • Date: 2012-10-10 22:28:55 UTC
  • Revision ID: package-import@ubuntu.com-20121010222855-qepocc61xktv6gs9
Tags: 3.5.0-17.1
https://launchpad.net/bugs/1066123
* Open Quantal LBM
* Add compat-wireless 3.6
  -LP: #1066123

Show diffs side-by-side

added added

removed removed

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