linux/net/mac80211/cfg.c
<<
>>
Prefs
   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
  23static 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
  45static 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
  52static 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
 105static 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
 115static 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
 171static 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
 212static 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
 305static 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
 317static 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
 328static 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
 339void 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
 353static 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
 456static 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
 467static 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
 484static 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
 562do_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
 617static 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
 631static 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
 653static 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
 661static 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
 682static 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
 718static 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
 725static 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
 751static 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
 823static 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
 881static 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
 901static 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) */
 927struct 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
 937static 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
 970static 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
1132static 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
1193static 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
1208static 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
1295static 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
1329static 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
1341static 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
1371static 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
1413static 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
1434static 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
1455static 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
1466static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
1467{
1468        return (mask >> (parm-1)) & 0x1;
1469}
1470
1471static 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
1512static 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
1610static 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
1633static 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
1643static 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
1710static 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
1750static int ieee80211_suspend(struct wiphy *wiphy,
1751                             struct cfg80211_wowlan *wowlan)
1752{
1753        return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
1754}
1755
1756static 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
1765static 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
1797static int
1798ieee80211_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
1810static int
1811ieee80211_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
1821static 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
1827static 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
1847static 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
1853static 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
1859static 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
1881static 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
1888static 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
1925static 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
1956static 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
1965static 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
1975static 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
1983static 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
1993static 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
2007int __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
2053static 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
2085static 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
2108static 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
2135static 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
2302static 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
2321static 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
2395static 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
2405static 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
2517static 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
2526static 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
2557static 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
2567static 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
2574static 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
2581static 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
2589static 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
2604static 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
2617static 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
2634static 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
2649static int
2650ieee80211_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
2721static int
2722ieee80211_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
2760static 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
2873fail:
2874        dev_kfree_skb(skb);
2875        return ret;
2876}
2877
2878static 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
2918static 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
2986static struct ieee80211_channel *
2987ieee80211_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
2997static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
2998{
2999        drv_set_wakeup(wiphy_priv(wiphy), enabled);
3000}
3001#endif
3002
3003struct 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};
3078
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.