net/mac80211/cfg.c

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