net/mac80211/cfg.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * mac80211 configuration hooks for cfg80211
   4  *
   5  * Copyright 2006-2010  Johannes Berg <johannes@sipsolutions.net>
   6  * Copyright 2013-2015  Intel Mobile Communications GmbH
   7  * Copyright (C) 2015-2017 Intel Deutschland GmbH
   8  * Copyright (C) 2018-2020 Intel Corporation
   9  */
  10
  11 #include <linux/ieee80211.h>
  12 #include <linux/nl80211.h>
  13 #include <linux/rtnetlink.h>
  14 #include <linux/slab.h>
  15 #include <net/net_namespace.h>
  16 #include <linux/rcupdate.h>
  17 #include <linux/fips.h>
  18 #include <linux/if_ether.h>
  19 #include <net/cfg80211.h>
  20 #include "ieee80211_i.h"
  21 #include "driver-ops.h"
  22 #include "rate.h"
  23 #include "mesh.h"
  24 #include "wme.h"
  25
  26 static void ieee80211_set_mu_mimo_follow(struct ieee80211_sub_if_data *sdata,
  27                                          struct vif_params *params)
  28 {
  29         bool mu_mimo_groups = false;
  30         bool mu_mimo_follow = false;
  31
  32         if (params->vht_mumimo_groups) {
  33                 u64 membership;
  34
  35                 BUILD_BUG_ON(sizeof(membership) != WLAN_MEMBERSHIP_LEN);
  36
  37                 memcpy(sdata->vif.bss_conf.mu_group.membership,
  38                        params->vht_mumimo_groups, WLAN_MEMBERSHIP_LEN);
  39                 memcpy(sdata->vif.bss_conf.mu_group.position,
  40                        params->vht_mumimo_groups + WLAN_MEMBERSHIP_LEN,
  41                        WLAN_USER_POSITION_LEN);
  42                 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_MU_GROUPS);
  43                 /* don't care about endianness - just check for 0 */
  44                 memcpy(&membership, params->vht_mumimo_groups,
  45                        WLAN_MEMBERSHIP_LEN);
  46                 mu_mimo_groups = membership != 0;
  47         }
  48
  49         if (params->vht_mumimo_follow_addr) {
  50                 mu_mimo_follow =
  51                         is_valid_ether_addr(params->vht_mumimo_follow_addr);
  52                 ether_addr_copy(sdata->u.mntr.mu_follow_addr,
  53                                 params->vht_mumimo_follow_addr);
  54         }
  55
  56         sdata->vif.mu_mimo_owner = mu_mimo_groups || mu_mimo_follow;
  57 }
  58
  59 static int ieee80211_set_mon_options(struct ieee80211_sub_if_data *sdata,
  60                                      struct vif_params *params)
  61 {
  62         struct ieee80211_local *local = sdata->local;
  63         struct ieee80211_sub_if_data *monitor_sdata;
  64
  65         /* check flags first */
  66         if (params->flags && ieee80211_sdata_running(sdata)) {
  67                 u32 mask = MONITOR_FLAG_COOK_FRAMES | MONITOR_FLAG_ACTIVE;
  68
  69                 /*
  70                  * Prohibit MONITOR_FLAG_COOK_FRAMES and
  71                  * MONITOR_FLAG_ACTIVE to be changed while the
  72                  * interface is up.
  73                  * Else we would need to add a lot of cruft
  74                  * to update everything:
  75                  *      cooked_mntrs, monitor and all fif_* counters
  76                  *      reconfigure hardware
  77                  */
  78                 if ((params->flags & mask) != (sdata->u.mntr.flags & mask))
  79                         return -EBUSY;
  80         }
  81
  82         /* also validate MU-MIMO change */
  83         monitor_sdata = rtnl_dereference(local->monitor_sdata);
  84
  85         if (!monitor_sdata &&
  86             (params->vht_mumimo_groups || params->vht_mumimo_follow_addr))
  87                 return -EOPNOTSUPP;
  88
  89         /* apply all changes now - no failures allowed */
  90
  91         if (monitor_sdata)
  92                 ieee80211_set_mu_mimo_follow(monitor_sdata, params);
  93
  94         if (params->flags) {
  95                 if (ieee80211_sdata_running(sdata)) {
  96                         ieee80211_adjust_monitor_flags(sdata, -1);
  97                         sdata->u.mntr.flags = params->flags;
  98                         ieee80211_adjust_monitor_flags(sdata, 1);
  99
 100                         ieee80211_configure_filter(local);
 101                 } else {
 102                         /*
 103                          * Because the interface is down, ieee80211_do_stop
 104                          * and ieee80211_do_open take care of "everything"
 105                          * mentioned in the comment above.
 106                          */
 107                         sdata->u.mntr.flags = params->flags;
 108                 }
 109         }
 110
 111         return 0;
 112 }
 113
 114 static struct wireless_dev *ieee80211_add_iface(struct wiphy *wiphy,
 115                                                 const char *name,
 116                                                 unsigned char name_assign_type,
 117                                                 enum nl80211_iftype type,
 118                                                 struct vif_params *params)
 119 {
 120         struct ieee80211_local *local = wiphy_priv(wiphy);
 121         struct wireless_dev *wdev;
 122         struct ieee80211_sub_if_data *sdata;
 123         int err;
 124
 125         err = ieee80211_if_add(local, name, name_assign_type, &wdev, type, params);
 126         if (err)
 127                 return ERR_PTR(err);
 128
 129         sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 130
 131         if (type == NL80211_IFTYPE_MONITOR) {
 132                 err = ieee80211_set_mon_options(sdata, params);
 133                 if (err) {
 134                         ieee80211_if_remove(sdata);
 135                         return NULL;
 136                 }
 137         }
 138
 139         return wdev;
 140 }
 141
 142 static int ieee80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
 143 {
 144         ieee80211_if_remove(IEEE80211_WDEV_TO_SUB_IF(wdev));
 145
 146         return 0;
 147 }
 148
 149 static int ieee80211_change_iface(struct wiphy *wiphy,
 150                                   struct net_device *dev,
 151                                   enum nl80211_iftype type,
 152                                   struct vif_params *params)
 153 {
 154         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 155         struct ieee80211_local *local = sdata->local;
 156         struct sta_info *sta;
 157         int ret;
 158
 159         ret = ieee80211_if_change_type(sdata, type);
 160         if (ret)
 161                 return ret;
 162
 163         if (type == NL80211_IFTYPE_AP_VLAN && params->use_4addr == 0) {
 164                 RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
 165                 ieee80211_check_fast_rx_iface(sdata);
 166         } else if (type == NL80211_IFTYPE_STATION && params->use_4addr >= 0) {
 167                 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 168
 169                 if (params->use_4addr == ifmgd->use_4addr)
 170                         return 0;
 171
 172                 sdata->u.mgd.use_4addr = params->use_4addr;
 173                 if (!ifmgd->associated)
 174                         return 0;
 175
 176                 mutex_lock(&local->sta_mtx);
 177                 sta = sta_info_get(sdata, ifmgd->bssid);
 178                 if (sta)
 179                         drv_sta_set_4addr(local, sdata, &sta->sta,
 180                                           params->use_4addr);
 181                 mutex_unlock(&local->sta_mtx);
 182
 183                 if (params->use_4addr)
 184                         ieee80211_send_4addr_nullfunc(local, sdata);
 185         }
 186
 187         if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
 188                 ret = ieee80211_set_mon_options(sdata, params);
 189                 if (ret)
 190                         return ret;
 191         }
 192
 193         return 0;
 194 }
 195
 196 static int ieee80211_start_p2p_device(struct wiphy *wiphy,
 197                                       struct wireless_dev *wdev)
 198 {
 199         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 200         int ret;
 201
 202         mutex_lock(&sdata->local->chanctx_mtx);
 203         ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
 204         mutex_unlock(&sdata->local->chanctx_mtx);
 205         if (ret < 0)
 206                 return ret;
 207
 208         return ieee80211_do_open(wdev, true);
 209 }
 210
 211 static void ieee80211_stop_p2p_device(struct wiphy *wiphy,
 212                                       struct wireless_dev *wdev)
 213 {
 214         ieee80211_sdata_stop(IEEE80211_WDEV_TO_SUB_IF(wdev));
 215 }
 216
 217 static int ieee80211_start_nan(struct wiphy *wiphy,
 218                                struct wireless_dev *wdev,
 219                                struct cfg80211_nan_conf *conf)
 220 {
 221         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 222         int ret;
 223
 224         mutex_lock(&sdata->local->chanctx_mtx);
 225         ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
 226         mutex_unlock(&sdata->local->chanctx_mtx);
 227         if (ret < 0)
 228                 return ret;
 229
 230         ret = ieee80211_do_open(wdev, true);
 231         if (ret)
 232                 return ret;
 233
 234         ret = drv_start_nan(sdata->local, sdata, conf);
 235         if (ret)
 236                 ieee80211_sdata_stop(sdata);
 237
 238         sdata->u.nan.conf = *conf;
 239
 240         return ret;
 241 }
 242
 243 static void ieee80211_stop_nan(struct wiphy *wiphy,
 244                                struct wireless_dev *wdev)
 245 {
 246         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 247
 248         drv_stop_nan(sdata->local, sdata);
 249         ieee80211_sdata_stop(sdata);
 250 }
 251
 252 static int ieee80211_nan_change_conf(struct wiphy *wiphy,
 253                                      struct wireless_dev *wdev,
 254                                      struct cfg80211_nan_conf *conf,
 255                                      u32 changes)
 256 {
 257         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 258         struct cfg80211_nan_conf new_conf;
 259         int ret = 0;
 260
 261         if (sdata->vif.type != NL80211_IFTYPE_NAN)
 262                 return -EOPNOTSUPP;
 263
 264         if (!ieee80211_sdata_running(sdata))
 265                 return -ENETDOWN;
 266
 267         new_conf = sdata->u.nan.conf;
 268
 269         if (changes & CFG80211_NAN_CONF_CHANGED_PREF)
 270                 new_conf.master_pref = conf->master_pref;
 271
 272         if (changes & CFG80211_NAN_CONF_CHANGED_BANDS)
 273                 new_conf.bands = conf->bands;
 274
 275         ret = drv_nan_change_conf(sdata->local, sdata, &new_conf, changes);
 276         if (!ret)
 277                 sdata->u.nan.conf = new_conf;
 278
 279         return ret;
 280 }
 281
 282 static int ieee80211_add_nan_func(struct wiphy *wiphy,
 283                                   struct wireless_dev *wdev,
 284                                   struct cfg80211_nan_func *nan_func)
 285 {
 286         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 287         int ret;
 288
 289         if (sdata->vif.type != NL80211_IFTYPE_NAN)
 290                 return -EOPNOTSUPP;
 291
 292         if (!ieee80211_sdata_running(sdata))
 293                 return -ENETDOWN;
 294
 295         spin_lock_bh(&sdata->u.nan.func_lock);
 296
 297         ret = idr_alloc(&sdata->u.nan.function_inst_ids,
 298                         nan_func, 1, sdata->local->hw.max_nan_de_entries + 1,
 299                         GFP_ATOMIC);
 300         spin_unlock_bh(&sdata->u.nan.func_lock);
 301
 302         if (ret < 0)
 303                 return ret;
 304
 305         nan_func->instance_id = ret;
 306
 307         WARN_ON(nan_func->instance_id == 0);
 308
 309         ret = drv_add_nan_func(sdata->local, sdata, nan_func);
 310         if (ret) {
 311                 spin_lock_bh(&sdata->u.nan.func_lock);
 312                 idr_remove(&sdata->u.nan.function_inst_ids,
 313                            nan_func->instance_id);
 314                 spin_unlock_bh(&sdata->u.nan.func_lock);
 315         }
 316
 317         return ret;
 318 }
 319
 320 static struct cfg80211_nan_func *
 321 ieee80211_find_nan_func_by_cookie(struct ieee80211_sub_if_data *sdata,
 322                                   u64 cookie)
 323 {
 324         struct cfg80211_nan_func *func;
 325         int id;
 326
 327         lockdep_assert_held(&sdata->u.nan.func_lock);
 328
 329         idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id) {
 330                 if (func->cookie == cookie)
 331                         return func;
 332         }
 333
 334         return NULL;
 335 }
 336
 337 static void ieee80211_del_nan_func(struct wiphy *wiphy,
 338                                   struct wireless_dev *wdev, u64 cookie)
 339 {
 340         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 341         struct cfg80211_nan_func *func;
 342         u8 instance_id = 0;
 343
 344         if (sdata->vif.type != NL80211_IFTYPE_NAN ||
 345             !ieee80211_sdata_running(sdata))
 346                 return;
 347
 348         spin_lock_bh(&sdata->u.nan.func_lock);
 349
 350         func = ieee80211_find_nan_func_by_cookie(sdata, cookie);
 351         if (func)
 352                 instance_id = func->instance_id;
 353
 354         spin_unlock_bh(&sdata->u.nan.func_lock);
 355
 356         if (instance_id)
 357                 drv_del_nan_func(sdata->local, sdata, instance_id);
 358 }
 359
 360 static int ieee80211_set_noack_map(struct wiphy *wiphy,
 361                                   struct net_device *dev,
 362                                   u16 noack_map)
 363 {
 364         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 365
 366         sdata->noack_map = noack_map;
 367
 368         ieee80211_check_fast_xmit_iface(sdata);
 369
 370         return 0;
 371 }
 372
 373 static int ieee80211_set_tx(struct ieee80211_sub_if_data *sdata,
 374                             const u8 *mac_addr, u8 key_idx)
 375 {
 376         struct ieee80211_local *local = sdata->local;
 377         struct ieee80211_key *key;
 378         struct sta_info *sta;
 379         int ret = -EINVAL;
 380
 381         if (!wiphy_ext_feature_isset(local->hw.wiphy,
 382                                      NL80211_EXT_FEATURE_EXT_KEY_ID))
 383                 return -EINVAL;
 384
 385         sta = sta_info_get_bss(sdata, mac_addr);
 386
 387         if (!sta)
 388                 return -EINVAL;
 389
 390         if (sta->ptk_idx == key_idx)
 391                 return 0;
 392
 393         mutex_lock(&local->key_mtx);
 394         key = key_mtx_dereference(local, sta->ptk[key_idx]);
 395
 396         if (key && key->conf.flags & IEEE80211_KEY_FLAG_NO_AUTO_TX)
 397                 ret = ieee80211_set_tx_key(key);
 398
 399         mutex_unlock(&local->key_mtx);
 400         return ret;
 401 }
 402
 403 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
 404                              u8 key_idx, bool pairwise, const u8 *mac_addr,
 405                              struct key_params *params)
 406 {
 407         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 408         struct ieee80211_local *local = sdata->local;
 409         struct sta_info *sta = NULL;
 410         const struct ieee80211_cipher_scheme *cs = NULL;
 411         struct ieee80211_key *key;
 412         int err;
 413
 414         if (!ieee80211_sdata_running(sdata))
 415                 return -ENETDOWN;
 416
 417         if (pairwise && params->mode == NL80211_KEY_SET_TX)
 418                 return ieee80211_set_tx(sdata, mac_addr, key_idx);
 419
 420         /* reject WEP and TKIP keys if WEP failed to initialize */
 421         switch (params->cipher) {
 422         case WLAN_CIPHER_SUITE_WEP40:
 423         case WLAN_CIPHER_SUITE_TKIP:
 424         case WLAN_CIPHER_SUITE_WEP104:
 425                 if (WARN_ON_ONCE(fips_enabled))
 426                         return -EINVAL;
 427         case WLAN_CIPHER_SUITE_CCMP:
 428         case WLAN_CIPHER_SUITE_CCMP_256:
 429         case WLAN_CIPHER_SUITE_AES_CMAC:
 430         case WLAN_CIPHER_SUITE_BIP_CMAC_256:
 431         case WLAN_CIPHER_SUITE_BIP_GMAC_128:
 432         case WLAN_CIPHER_SUITE_BIP_GMAC_256:
 433         case WLAN_CIPHER_SUITE_GCMP:
 434         case WLAN_CIPHER_SUITE_GCMP_256:
 435                 break;
 436         default:
 437                 cs = ieee80211_cs_get(local, params->cipher, sdata->vif.type);
 438                 break;
 439         }
 440
 441         key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
 442                                   params->key, params->seq_len, params->seq,
 443                                   cs);
 444         if (IS_ERR(key))
 445                 return PTR_ERR(key);
 446
 447         if (pairwise)
 448                 key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
 449
 450         if (params->mode == NL80211_KEY_NO_TX)
 451                 key->conf.flags |= IEEE80211_KEY_FLAG_NO_AUTO_TX;
 452
 453         mutex_lock(&local->sta_mtx);
 454
 455         if (mac_addr) {
 456                 sta = sta_info_get_bss(sdata, mac_addr);
 457                 /*
 458                  * The ASSOC test makes sure the driver is ready to
 459                  * receive the key. When wpa_supplicant has roamed
 460                  * using FT, it attempts to set the key before
 461                  * association has completed, this rejects that attempt
 462                  * so it will set the key again after association.
 463                  *
 464                  * TODO: accept the key if we have a station entry and
 465                  *       add it to the device after the station.
 466                  */
 467                 if (!sta || !test_sta_flag(sta, WLAN_STA_ASSOC)) {
 468                         ieee80211_key_free_unused(key);
 469                         err = -ENOENT;
 470                         goto out_unlock;
 471                 }
 472         }
 473
 474         switch (sdata->vif.type) {
 475         case NL80211_IFTYPE_STATION:
 476                 if (sdata->u.mgd.mfp != IEEE80211_MFP_DISABLED)
 477                         key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
 478                 break;
 479         case NL80211_IFTYPE_AP:
 480         case NL80211_IFTYPE_AP_VLAN:
 481                 /* Keys without a station are used for TX only */
 482                 if (sta && test_sta_flag(sta, WLAN_STA_MFP))
 483                         key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
 484                 break;
 485         case NL80211_IFTYPE_ADHOC:
 486                 /* no MFP (yet) */
 487                 break;
 488         case NL80211_IFTYPE_MESH_POINT:
 489 #ifdef CONFIG_MAC80211_MESH
 490                 if (sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
 491                         key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
 492                 break;
 493 #endif
 494         case NL80211_IFTYPE_WDS:
 495         case NL80211_IFTYPE_MONITOR:
 496         case NL80211_IFTYPE_P2P_DEVICE:
 497         case NL80211_IFTYPE_NAN:
 498         case NL80211_IFTYPE_UNSPECIFIED:
 499         case NUM_NL80211_IFTYPES:
 500         case NL80211_IFTYPE_P2P_CLIENT:
 501         case NL80211_IFTYPE_P2P_GO:
 502         case NL80211_IFTYPE_OCB:
 503                 /* shouldn't happen */
 504                 WARN_ON_ONCE(1);
 505                 break;
 506         }
 507
 508         if (sta)
 509                 sta->cipher_scheme = cs;
 510
 511         err = ieee80211_key_link(key, sdata, sta);
 512
 513  out_unlock:
 514         mutex_unlock(&local->sta_mtx);
 515
 516         return err;
 517 }
 518
 519 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
 520                              u8 key_idx, bool pairwise, const u8 *mac_addr)
 521 {
 522         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 523         struct ieee80211_local *local = sdata->local;
 524         struct sta_info *sta;
 525         struct ieee80211_key *key = NULL;
 526         int ret;
 527
 528         mutex_lock(&local->sta_mtx);
 529         mutex_lock(&local->key_mtx);
 530
 531         if (mac_addr) {
 532                 ret = -ENOENT;
 533
 534                 sta = sta_info_get_bss(sdata, mac_addr);
 535                 if (!sta)
 536                         goto out_unlock;
 537
 538                 if (pairwise)
 539                         key = key_mtx_dereference(local, sta->ptk[key_idx]);
 540                 else
 541                         key = key_mtx_dereference(local, sta->gtk[key_idx]);
 542         } else
 543                 key = key_mtx_dereference(local, sdata->keys[key_idx]);
 544
 545         if (!key) {
 546                 ret = -ENOENT;
 547                 goto out_unlock;
 548         }
 549
 550         ieee80211_key_free(key, sdata->vif.type == NL80211_IFTYPE_STATION);
 551
 552         ret = 0;
 553  out_unlock:
 554         mutex_unlock(&local->key_mtx);
 555         mutex_unlock(&local->sta_mtx);
 556
 557         return ret;
 558 }
 559
 560 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
 561                              u8 key_idx, bool pairwise, const u8 *mac_addr,
 562                              void *cookie,
 563                              void (*callback)(void *cookie,
 564                                               struct key_params *params))
 565 {
 566         struct ieee80211_sub_if_data *sdata;
 567         struct sta_info *sta = NULL;
 568         u8 seq[6] = {0};
 569         struct key_params params;
 570         struct ieee80211_key *key = NULL;
 571         u64 pn64;
 572         u32 iv32;
 573         u16 iv16;
 574         int err = -ENOENT;
 575         struct ieee80211_key_seq kseq = {};
 576
 577         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 578
 579         rcu_read_lock();
 580
 581         if (mac_addr) {
 582                 sta = sta_info_get_bss(sdata, mac_addr);
 583                 if (!sta)
 584                         goto out;
 585
 586                 if (pairwise && key_idx < NUM_DEFAULT_KEYS)
 587                         key = rcu_dereference(sta->ptk[key_idx]);
 588                 else if (!pairwise &&
 589                          key_idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS +
 590                          NUM_DEFAULT_BEACON_KEYS)
 591                         key = rcu_dereference(sta->gtk[key_idx]);
 592         } else
 593                 key = rcu_dereference(sdata->keys[key_idx]);
 594
 595         if (!key)
 596                 goto out;
 597
 598         memset(&params, 0, sizeof(params));
 599
 600         params.cipher = key->conf.cipher;
 601
 602         switch (key->conf.cipher) {
 603         case WLAN_CIPHER_SUITE_TKIP:
 604                 pn64 = atomic64_read(&key->conf.tx_pn);
 605                 iv32 = TKIP_PN_TO_IV32(pn64);
 606                 iv16 = TKIP_PN_TO_IV16(pn64);
 607
 608                 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
 609                     !(key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
 610                         drv_get_key_seq(sdata->local, key, &kseq);
 611                         iv32 = kseq.tkip.iv32;
 612                         iv16 = kseq.tkip.iv16;
 613                 }
 614
 615                 seq[0] = iv16 & 0xff;
 616                 seq[1] = (iv16 >> 8) & 0xff;
 617                 seq[2] = iv32 & 0xff;
 618                 seq[3] = (iv32 >> 8) & 0xff;
 619                 seq[4] = (iv32 >> 16) & 0xff;
 620                 seq[5] = (iv32 >> 24) & 0xff;
 621                 params.seq = seq;
 622                 params.seq_len = 6;
 623                 break;
 624         case WLAN_CIPHER_SUITE_CCMP:
 625         case WLAN_CIPHER_SUITE_CCMP_256:
 626         case WLAN_CIPHER_SUITE_AES_CMAC:
 627         case WLAN_CIPHER_SUITE_BIP_CMAC_256:
 628                 BUILD_BUG_ON(offsetof(typeof(kseq), ccmp) !=
 629                              offsetof(typeof(kseq), aes_cmac));
 630                 fallthrough;
 631         case WLAN_CIPHER_SUITE_BIP_GMAC_128:
 632         case WLAN_CIPHER_SUITE_BIP_GMAC_256:
 633                 BUILD_BUG_ON(offsetof(typeof(kseq), ccmp) !=
 634                              offsetof(typeof(kseq), aes_gmac));
 635                 fallthrough;
 636         case WLAN_CIPHER_SUITE_GCMP:
 637         case WLAN_CIPHER_SUITE_GCMP_256:
 638                 BUILD_BUG_ON(offsetof(typeof(kseq), ccmp) !=
 639                              offsetof(typeof(kseq), gcmp));
 640
 641                 if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
 642                     !(key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
 643                         drv_get_key_seq(sdata->local, key, &kseq);
 644                         memcpy(seq, kseq.ccmp.pn, 6);
 645                 } else {
 646                         pn64 = atomic64_read(&key->conf.tx_pn);
 647                         seq[0] = pn64;
 648                         seq[1] = pn64 >> 8;
 649                         seq[2] = pn64 >> 16;
 650                         seq[3] = pn64 >> 24;
 651                         seq[4] = pn64 >> 32;
 652                         seq[5] = pn64 >> 40;
 653                 }
 654                 params.seq = seq;
 655                 params.seq_len = 6;
 656                 break;
 657         default:
 658                 if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
 659                         break;
 660                 if (WARN_ON(key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV))
 661                         break;
 662                 drv_get_key_seq(sdata->local, key, &kseq);
 663                 params.seq = kseq.hw.seq;
 664                 params.seq_len = kseq.hw.seq_len;
 665                 break;
 666         }
 667
 668         params.key = key->conf.key;
 669         params.key_len = key->conf.keylen;
 670
 671         callback(cookie, &params);
 672         err = 0;
 673
 674  out:
 675         rcu_read_unlock();
 676         return err;
 677 }
 678
 679 static int ieee80211_config_default_key(struct wiphy *wiphy,
 680                                         struct net_device *dev,
 681                                         u8 key_idx, bool uni,
 682                                         bool multi)
 683 {
 684         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 685
 686         ieee80211_set_default_key(sdata, key_idx, uni, multi);
 687
 688         return 0;
 689 }
 690
 691 static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
 692                                              struct net_device *dev,
 693                                              u8 key_idx)
 694 {
 695         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 696
 697         ieee80211_set_default_mgmt_key(sdata, key_idx);
 698
 699         return 0;
 700 }
 701
 702 static int ieee80211_config_default_beacon_key(struct wiphy *wiphy,
 703                                                struct net_device *dev,
 704                                                u8 key_idx)
 705 {
 706         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 707
 708         ieee80211_set_default_beacon_key(sdata, key_idx);
 709
 710         return 0;
 711 }
 712
 713 void sta_set_rate_info_tx(struct sta_info *sta,
 714                           const struct ieee80211_tx_rate *rate,
 715                           struct rate_info *rinfo)
 716 {
 717         rinfo->flags = 0;
 718         if (rate->flags & IEEE80211_TX_RC_MCS) {
 719                 rinfo->flags |= RATE_INFO_FLAGS_MCS;
 720                 rinfo->mcs = rate->idx;
 721         } else if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
 722                 rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
 723                 rinfo->mcs = ieee80211_rate_get_vht_mcs(rate);
 724                 rinfo->nss = ieee80211_rate_get_vht_nss(rate);
 725         } else {
 726                 struct ieee80211_supported_band *sband;
 727                 int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
 728                 u16 brate;
 729
 730                 sband = ieee80211_get_sband(sta->sdata);
 731                 WARN_ON_ONCE(sband && !sband->bitrates);
 732                 if (sband && sband->bitrates) {
 733                         brate = sband->bitrates[rate->idx].bitrate;
 734                         rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
 735                 }
 736         }
 737         if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
 738                 rinfo->bw = RATE_INFO_BW_40;
 739         else if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
 740                 rinfo->bw = RATE_INFO_BW_80;
 741         else if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
 742                 rinfo->bw = RATE_INFO_BW_160;
 743         else
 744                 rinfo->bw = RATE_INFO_BW_20;
 745         if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
 746                 rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
 747 }
 748
 749 static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
 750                                   int idx, u8 *mac, struct station_info *sinfo)
 751 {
 752         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 753         struct ieee80211_local *local = sdata->local;
 754         struct sta_info *sta;
 755         int ret = -ENOENT;
 756
 757         mutex_lock(&local->sta_mtx);
 758
 759         sta = sta_info_get_by_idx(sdata, idx);
 760         if (sta) {
 761                 ret = 0;
 762                 memcpy(mac, sta->sta.addr, ETH_ALEN);
 763                 sta_set_sinfo(sta, sinfo, true);
 764         }
 765
 766         mutex_unlock(&local->sta_mtx);
 767
 768         return ret;
 769 }
 770
 771 static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
 772                                  int idx, struct survey_info *survey)
 773 {
 774         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
 775
 776         return drv_get_survey(local, idx, survey);
 777 }
 778
 779 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
 780                                  const u8 *mac, struct station_info *sinfo)
 781 {
 782         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
 783         struct ieee80211_local *local = sdata->local;
 784         struct sta_info *sta;
 785         int ret = -ENOENT;
 786
 787         mutex_lock(&local->sta_mtx);
 788
 789         sta = sta_info_get_bss(sdata, mac);
 790         if (sta) {
 791                 ret = 0;
 792                 sta_set_sinfo(sta, sinfo, true);
 793         }
 794
 795         mutex_unlock(&local->sta_mtx);
 796
 797         return ret;
 798 }
 799
 800 static int ieee80211_set_monitor_channel(struct wiphy *wiphy,
 801                                          struct cfg80211_chan_def *chandef)
 802 {
 803         struct ieee80211_local *local = wiphy_priv(wiphy);
 804         struct ieee80211_sub_if_data *sdata;
 805         int ret = 0;
 806
 807         if (cfg80211_chandef_identical(&local->monitor_chandef, chandef))
 808                 return 0;
 809
 810         mutex_lock(&local->mtx);
 811         if (local->use_chanctx) {
 812                 sdata = rtnl_dereference(local->monitor_sdata);
 813                 if (sdata) {
 814                         ieee80211_vif_release_channel(sdata);
 815                         ret = ieee80211_vif_use_channel(sdata, chandef,
 816                                         IEEE80211_CHANCTX_EXCLUSIVE);
 817                 }
 818         } else if (local->open_count == local->monitors) {
 819                 local->_oper_chandef = *chandef;
 820                 ieee80211_hw_config(local, 0);
 821         }
 822
 823         if (ret == 0)
 824                 local->monitor_chandef = *chandef;
 825         mutex_unlock(&local->mtx);
 826
 827         return ret;
 828 }
 829
 830 static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
 831                                     const u8 *resp, size_t resp_len,
 832                                     const struct ieee80211_csa_settings *csa)
 833 {
 834         struct probe_resp *new, *old;
 835
 836         if (!resp || !resp_len)
 837                 return 1;
 838
 839         old = sdata_dereference(sdata->u.ap.probe_resp, sdata);
 840
 841         new = kzalloc(sizeof(struct probe_resp) + resp_len, GFP_KERNEL);
 842         if (!new)
 843                 return -ENOMEM;
 844
 845         new->len = resp_len;
 846         memcpy(new->data, resp, resp_len);
 847
 848         if (csa)
 849                 memcpy(new->cntdwn_counter_offsets, csa->counter_offsets_presp,
 850                        csa->n_counter_offsets_presp *
 851                        sizeof(new->cntdwn_counter_offsets[0]));
 852
 853         rcu_assign_pointer(sdata->u.ap.probe_resp, new);
 854         if (old)
 855                 kfree_rcu(old, rcu_head);
 856
 857         return 0;
 858 }
 859
 860 static int ieee80211_set_fils_discovery(struct ieee80211_sub_if_data *sdata,
 861                                         struct cfg80211_fils_discovery *params)
 862 {
 863         struct fils_discovery_data *new, *old = NULL;
 864         struct ieee80211_fils_discovery *fd;
 865
 866         if (!params->tmpl || !params->tmpl_len)
 867                 return -EINVAL;
 868
 869         fd = &sdata->vif.bss_conf.fils_discovery;
 870         fd->min_interval = params->min_interval;
 871         fd->max_interval = params->max_interval;
 872
 873         old = sdata_dereference(sdata->u.ap.fils_discovery, sdata);
 874         new = kzalloc(sizeof(*new) + params->tmpl_len, GFP_KERNEL);
 875         if (!new)
 876                 return -ENOMEM;
 877         new->len = params->tmpl_len;
 878         memcpy(new->data, params->tmpl, params->tmpl_len);
 879         rcu_assign_pointer(sdata->u.ap.fils_discovery, new);
 880
 881         if (old)
 882                 kfree_rcu(old, rcu_head);
 883
 884         return 0;
 885 }
 886
 887 static int
 888 ieee80211_set_unsol_bcast_probe_resp(struct ieee80211_sub_if_data *sdata,
 889                                      struct cfg80211_unsol_bcast_probe_resp *params)
 890 {
 891         struct unsol_bcast_probe_resp_data *new, *old = NULL;
 892
 893         if (!params->tmpl || !params->tmpl_len)
 894                 return -EINVAL;
 895
 896         old = sdata_dereference(sdata->u.ap.unsol_bcast_probe_resp, sdata);
 897         new = kzalloc(sizeof(*new) + params->tmpl_len, GFP_KERNEL);
 898         if (!new)
 899                 return -ENOMEM;
 900         new->len = params->tmpl_len;
 901         memcpy(new->data, params->tmpl, params->tmpl_len);
 902         rcu_assign_pointer(sdata->u.ap.unsol_bcast_probe_resp, new);
 903
 904         if (old)
 905                 kfree_rcu(old, rcu_head);
 906
 907         sdata->vif.bss_conf.unsol_bcast_probe_resp_interval =
 908                                                         params->interval;
 909
 910         return 0;
 911 }
 912
 913 static int ieee80211_set_ftm_responder_params(
 914                                 struct ieee80211_sub_if_data *sdata,
 915                                 const u8 *lci, size_t lci_len,
 916                                 const u8 *civicloc, size_t civicloc_len)
 917 {
 918         struct ieee80211_ftm_responder_params *new, *old;
 919         struct ieee80211_bss_conf *bss_conf;
 920         u8 *pos;
 921         int len;
 922
 923         if (!lci_len && !civicloc_len)
 924                 return 0;
 925
 926         bss_conf = &sdata->vif.bss_conf;
 927         old = bss_conf->ftmr_params;
 928         len = lci_len + civicloc_len;
 929
 930         new = kzalloc(sizeof(*new) + len, GFP_KERNEL);
 931         if (!new)
 932                 return -ENOMEM;
 933
 934         pos = (u8 *)(new + 1);
 935         if (lci_len) {
 936                 new->lci_len = lci_len;
 937                 new->lci = pos;
 938                 memcpy(pos, lci, lci_len);
 939                 pos += lci_len;
 940         }
 941
 942         if (civicloc_len) {
 943                 new->civicloc_len = civicloc_len;
 944                 new->civicloc = pos;
 945                 memcpy(pos, civicloc, civicloc_len);
 946                 pos += civicloc_len;
 947         }
 948
 949         bss_conf->ftmr_params = new;
 950         kfree(old);
 951
 952         return 0;
 953 }
 954
 955 static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
 956                                    struct cfg80211_beacon_data *params,
 957                                    const struct ieee80211_csa_settings *csa)
 958 {
 959         struct beacon_data *new, *old;
 960         int new_head_len, new_tail_len;
 961         int size, err;
 962         u32 changed = BSS_CHANGED_BEACON;
 963
 964         old = sdata_dereference(sdata->u.ap.beacon, sdata);
 965
 966
 967         /* Need to have a beacon head if we don't have one yet */
 968         if (!params->head && !old)
 969                 return -EINVAL;
 970
 971         /* new or old head? */
 972         if (params->head)
 973                 new_head_len = params->head_len;
 974         else
 975                 new_head_len = old->head_len;
 976
 977         /* new or old tail? */
 978         if (params->tail || !old)
 979                 /* params->tail_len will be zero for !params->tail */
 980                 new_tail_len = params->tail_len;
 981         else
 982                 new_tail_len = old->tail_len;
 983
 984         size = sizeof(*new) + new_head_len + new_tail_len;
 985
 986         new = kzalloc(size, GFP_KERNEL);
 987         if (!new)
 988                 return -ENOMEM;
 989
 990         /* start filling the new info now */
 991
 992         /*
 993          * pointers go into the block we allocated,
 994          * memory is | beacon_data | head | tail |
 995          */
 996         new->head = ((u8 *) new) + sizeof(*new);
 997         new->tail = new->head + new_head_len;
 998         new->head_len = new_head_len;
 999         new->tail_len = new_tail_len;
1000
1001         if (csa) {
1002                 new->cntdwn_current_counter = csa->count;
1003                 memcpy(new->cntdwn_counter_offsets, csa->counter_offsets_beacon,
1004                        csa->n_counter_offsets_beacon *
1005                        sizeof(new->cntdwn_counter_offsets[0]));
1006         }
1007
1008         /* copy in head */
1009         if (params->head)
1010                 memcpy(new->head, params->head, new_head_len);
1011         else
1012                 memcpy(new->head, old->head, new_head_len);
1013
1014         /* copy in optional tail */
1015         if (params->tail)
1016                 memcpy(new->tail, params->tail, new_tail_len);
1017         else
1018                 if (old)
1019                         memcpy(new->tail, old->tail, new_tail_len);
1020
1021         err = ieee80211_set_probe_resp(sdata, params->probe_resp,
1022                                        params->probe_resp_len, csa);
1023         if (err < 0) {
1024                 kfree(new);
1025                 return err;
1026         }
1027         if (err == 0)
1028                 changed |= BSS_CHANGED_AP_PROBE_RESP;
1029
1030         if (params->ftm_responder != -1) {
1031                 sdata->vif.bss_conf.ftm_responder = params->ftm_responder;
1032                 err = ieee80211_set_ftm_responder_params(sdata,
1033                                                          params->lci,
1034                                                          params->lci_len,
1035                                                          params->civicloc,
1036                                                          params->civicloc_len);
1037
1038                 if (err < 0) {
1039                         kfree(new);
1040                         return err;
1041                 }
1042
1043                 changed |= BSS_CHANGED_FTM_RESPONDER;
1044         }
1045
1046         rcu_assign_pointer(sdata->u.ap.beacon, new);
1047
1048         if (old)
1049                 kfree_rcu(old, rcu_head);
1050
1051         return changed;
1052 }
1053
1054 static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
1055                               struct cfg80211_ap_settings *params)
1056 {
1057         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1058         struct ieee80211_local *local = sdata->local;
1059         struct beacon_data *old;
1060         struct ieee80211_sub_if_data *vlan;
1061         u32 changed = BSS_CHANGED_BEACON_INT |
1062                       BSS_CHANGED_BEACON_ENABLED |
1063                       BSS_CHANGED_BEACON |
1064                       BSS_CHANGED_SSID |
1065                       BSS_CHANGED_P2P_PS |
1066                       BSS_CHANGED_TXPOWER |
1067                       BSS_CHANGED_TWT;
1068         int i, err;
1069         int prev_beacon_int;
1070
1071         old = sdata_dereference(sdata->u.ap.beacon, sdata);
1072         if (old)
1073                 return -EALREADY;
1074
1075         if (params->smps_mode != NL80211_SMPS_OFF)
1076                 return -ENOTSUPP;
1077
1078         sdata->smps_mode = IEEE80211_SMPS_OFF;
1079
1080         sdata->needed_rx_chains = sdata->local->rx_chains;
1081
1082         prev_beacon_int = sdata->vif.bss_conf.beacon_int;
1083         sdata->vif.bss_conf.beacon_int = params->beacon_interval;
1084
1085         if (params->he_cap && params->he_oper) {
1086                 sdata->vif.bss_conf.he_support = true;
1087                 sdata->vif.bss_conf.htc_trig_based_pkt_ext =
1088                         le32_get_bits(params->he_oper->he_oper_params,
1089                               IEEE80211_HE_OPERATION_DFLT_PE_DURATION_MASK);
1090                 sdata->vif.bss_conf.frame_time_rts_th =
1091                         le32_get_bits(params->he_oper->he_oper_params,
1092                               IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK);
1093                 changed |= BSS_CHANGED_HE_OBSS_PD;
1094
1095                 if (params->he_bss_color.enabled)
1096                         changed |= BSS_CHANGED_HE_BSS_COLOR;
1097         }
1098
1099         mutex_lock(&local->mtx);
1100         err = ieee80211_vif_use_channel(sdata, &params->chandef,
1101                                         IEEE80211_CHANCTX_SHARED);
1102         if (!err)
1103                 ieee80211_vif_copy_chanctx_to_vlans(sdata, false);
1104         mutex_unlock(&local->mtx);
1105         if (err) {
1106                 sdata->vif.bss_conf.beacon_int = prev_beacon_int;
1107                 return err;
1108         }
1109
1110         /*
1111          * Apply control port protocol, this allows us to
1112          * not encrypt dynamic WEP control frames.
1113          */
1114         sdata->control_port_protocol = params->crypto.control_port_ethertype;
1115         sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt;
1116         sdata->control_port_over_nl80211 =
1117                                 params->crypto.control_port_over_nl80211;
1118         sdata->control_port_no_preauth =
1119                                 params->crypto.control_port_no_preauth;
1120         sdata->encrypt_headroom = ieee80211_cs_headroom(sdata->local,
1121                                                         &params->crypto,
1122                                                         sdata->vif.type);
1123
1124         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
1125                 vlan->control_port_protocol =
1126                         params->crypto.control_port_ethertype;
1127                 vlan->control_port_no_encrypt =
1128                         params->crypto.control_port_no_encrypt;
1129                 vlan->control_port_over_nl80211 =
1130                         params->crypto.control_port_over_nl80211;
1131                 vlan->control_port_no_preauth =
1132                         params->crypto.control_port_no_preauth;
1133                 vlan->encrypt_headroom =
1134                         ieee80211_cs_headroom(sdata->local,
1135                                               &params->crypto,
1136                                               vlan->vif.type);
1137         }
1138
1139         sdata->vif.bss_conf.dtim_period = params->dtim_period;
1140         sdata->vif.bss_conf.enable_beacon = true;
1141         sdata->vif.bss_conf.allow_p2p_go_ps = sdata->vif.p2p;
1142         sdata->vif.bss_conf.twt_responder = params->twt_responder;
1143         memcpy(&sdata->vif.bss_conf.he_obss_pd, &params->he_obss_pd,
1144                sizeof(struct ieee80211_he_obss_pd));
1145         memcpy(&sdata->vif.bss_conf.he_bss_color, &params->he_bss_color,
1146                sizeof(struct ieee80211_he_bss_color));
1147         sdata->vif.bss_conf.s1g = params->chandef.chan->band ==
1148                                   NL80211_BAND_S1GHZ;
1149
1150         sdata->vif.bss_conf.ssid_len = params->ssid_len;
1151         if (params->ssid_len)
1152                 memcpy(sdata->vif.bss_conf.ssid, params->ssid,
1153                        params->ssid_len);
1154         sdata->vif.bss_conf.hidden_ssid =
1155                 (params->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE);
1156
1157         memset(&sdata->vif.bss_conf.p2p_noa_attr, 0,
1158                sizeof(sdata->vif.bss_conf.p2p_noa_attr));
1159         sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow =
1160                 params->p2p_ctwindow & IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
1161         if (params->p2p_opp_ps)
1162                 sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
1163                                         IEEE80211_P2P_OPPPS_ENABLE_BIT;
1164
1165         sdata->beacon_rate_set = false;
1166         if (wiphy_ext_feature_isset(local->hw.wiphy,
1167                                     NL80211_EXT_FEATURE_BEACON_RATE_LEGACY)) {
1168                 for (i = 0; i < NUM_NL80211_BANDS; i++) {
1169                         sdata->beacon_rateidx_mask[i] =
1170                                 params->beacon_rate.control[i].legacy;
1171                         if (sdata->beacon_rateidx_mask[i])
1172                                 sdata->beacon_rate_set = true;
1173                 }
1174         }
1175
1176         if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
1177                 sdata->vif.bss_conf.beacon_tx_rate = params->beacon_rate;
1178
1179         err = ieee80211_assign_beacon(sdata, &params->beacon, NULL);
1180         if (err < 0)
1181                 goto error;
1182         changed |= err;
1183
1184         if (params->fils_discovery.max_interval) {
1185                 err = ieee80211_set_fils_discovery(sdata,
1186                                                    &params->fils_discovery);
1187                 if (err < 0)
1188                         goto error;
1189                 changed |= BSS_CHANGED_FILS_DISCOVERY;
1190         }
1191
1192         if (params->unsol_bcast_probe_resp.interval) {
1193                 err = ieee80211_set_unsol_bcast_probe_resp(sdata,
1194                                                            &params->unsol_bcast_probe_resp);
1195                 if (err < 0)
1196                         goto error;
1197                 changed |= BSS_CHANGED_UNSOL_BCAST_PROBE_RESP;
1198         }
1199
1200         err = drv_start_ap(sdata->local, sdata);
1201         if (err) {
1202                 old = sdata_dereference(sdata->u.ap.beacon, sdata);
1203
1204                 if (old)
1205                         kfree_rcu(old, rcu_head);
1206                 RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1207                 goto error;
1208         }
1209
1210         ieee80211_recalc_dtim(local, sdata);
1211         ieee80211_bss_info_change_notify(sdata, changed);
1212
1213         netif_carrier_on(dev);
1214         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1215                 netif_carrier_on(vlan->dev);
1216
1217         return 0;
1218
1219 error:
1220         mutex_lock(&local->mtx);
1221         ieee80211_vif_release_channel(sdata);
1222         mutex_unlock(&local->mtx);
1223
1224         return err;
1225 }
1226
1227 static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
1228                                    struct cfg80211_beacon_data *params)
1229 {
1230         struct ieee80211_sub_if_data *sdata;
1231         struct beacon_data *old;
1232         int err;
1233
1234         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1235         sdata_assert_lock(sdata);
1236
1237         /* don't allow changing the beacon while CSA is in place - offset
1238          * of channel switch counter may change
1239          */
1240         if (sdata->vif.csa_active)
1241                 return -EBUSY;
1242
1243         old = sdata_dereference(sdata->u.ap.beacon, sdata);
1244         if (!old)
1245                 return -ENOENT;
1246
1247         err = ieee80211_assign_beacon(sdata, params, NULL);
1248         if (err < 0)
1249                 return err;
1250         ieee80211_bss_info_change_notify(sdata, err);
1251         return 0;
1252 }
1253
1254 static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1255 {
1256         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1257         struct ieee80211_sub_if_data *vlan;
1258         struct ieee80211_local *local = sdata->local;
1259         struct beacon_data *old_beacon;
1260         struct probe_resp *old_probe_resp;
1261         struct fils_discovery_data *old_fils_discovery;
1262         struct unsol_bcast_probe_resp_data *old_unsol_bcast_probe_resp;
1263         struct cfg80211_chan_def chandef;
1264
1265         sdata_assert_lock(sdata);
1266
1267         old_beacon = sdata_dereference(sdata->u.ap.beacon, sdata);
1268         if (!old_beacon)
1269                 return -ENOENT;
1270         old_probe_resp = sdata_dereference(sdata->u.ap.probe_resp, sdata);
1271         old_fils_discovery = sdata_dereference(sdata->u.ap.fils_discovery,
1272                                                sdata);
1273         old_unsol_bcast_probe_resp =
1274                 sdata_dereference(sdata->u.ap.unsol_bcast_probe_resp,
1275                                   sdata);
1276
1277         /* abort any running channel switch */
1278         mutex_lock(&local->mtx);
1279         sdata->vif.csa_active = false;
1280         if (sdata->csa_block_tx) {
1281                 ieee80211_wake_vif_queues(local, sdata,
1282                                           IEEE80211_QUEUE_STOP_REASON_CSA);
1283                 sdata->csa_block_tx = false;
1284         }
1285
1286         mutex_unlock(&local->mtx);
1287
1288         kfree(sdata->u.ap.next_beacon);
1289         sdata->u.ap.next_beacon = NULL;
1290
1291         /* turn off carrier for this interface and dependent VLANs */
1292         list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1293                 netif_carrier_off(vlan->dev);
1294         netif_carrier_off(dev);
1295
1296         /* remove beacon and probe response */
1297         RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1298         RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
1299         RCU_INIT_POINTER(sdata->u.ap.fils_discovery, NULL);
1300         RCU_INIT_POINTER(sdata->u.ap.unsol_bcast_probe_resp, NULL);
1301         kfree_rcu(old_beacon, rcu_head);
1302         if (old_probe_resp)
1303                 kfree_rcu(old_probe_resp, rcu_head);
1304         if (old_fils_discovery)
1305                 kfree_rcu(old_fils_discovery, rcu_head);
1306         if (old_unsol_bcast_probe_resp)
1307                 kfree_rcu(old_unsol_bcast_probe_resp, rcu_head);
1308
1309         kfree(sdata->vif.bss_conf.ftmr_params);
1310         sdata->vif.bss_conf.ftmr_params = NULL;
1311
1312         __sta_info_flush(sdata, true);
1313         ieee80211_free_keys(sdata, true);
1314
1315         sdata->vif.bss_conf.enable_beacon = false;
1316         sdata->beacon_rate_set = false;
1317         sdata->vif.bss_conf.ssid_len = 0;
1318         clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
1319         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
1320
1321         if (sdata->wdev.cac_started) {
1322                 chandef = sdata->vif.bss_conf.chandef;
1323                 cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
1324                 cfg80211_cac_event(sdata->dev, &chandef,
1325                                    NL80211_RADAR_CAC_ABORTED,
1326                                    GFP_KERNEL);
1327         }
1328
1329         drv_stop_ap(sdata->local, sdata);
1330
1331         /* free all potentially still buffered bcast frames */
1332         local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps.bc_buf);
1333         ieee80211_purge_tx_queue(&local->hw, &sdata->u.ap.ps.bc_buf);
1334
1335         mutex_lock(&local->mtx);
1336         ieee80211_vif_copy_chanctx_to_vlans(sdata, true);
1337         ieee80211_vif_release_channel(sdata);
1338         mutex_unlock(&local->mtx);
1339
1340         return 0;
1341 }
1342
1343 static int sta_apply_auth_flags(struct ieee80211_local *local,
1344                                 struct sta_info *sta,
1345                                 u32 mask, u32 set)
1346 {
1347         int ret;
1348
1349         if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
1350             set & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
1351             !test_sta_flag(sta, WLAN_STA_AUTH)) {
1352                 ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
1353                 if (ret)
1354                         return ret;
1355         }
1356
1357         if (mask & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
1358             set & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
1359             !test_sta_flag(sta, WLAN_STA_ASSOC)) {
1360                 /*
1361                  * When peer becomes associated, init rate control as
1362                  * well. Some drivers require rate control initialized
1363                  * before drv_sta_state() is called.
1364                  */
1365                 if (!test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
1366                         rate_control_rate_init(sta);
1367
1368                 ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1369                 if (ret)
1370                         return ret;
1371         }
1372
1373         if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1374                 if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
1375                         ret = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
1376                 else if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1377                         ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1378                 else
1379                         ret = 0;
1380                 if (ret)
1381                         return ret;
1382         }
1383
1384         if (mask & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
1385             !(set & BIT(NL80211_STA_FLAG_ASSOCIATED)) &&
1386             test_sta_flag(sta, WLAN_STA_ASSOC)) {
1387                 ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
1388                 if (ret)
1389                         return ret;
1390         }
1391
1392         if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
1393             !(set & BIT(NL80211_STA_FLAG_AUTHENTICATED)) &&
1394             test_sta_flag(sta, WLAN_STA_AUTH)) {
1395                 ret = sta_info_move_state(sta, IEEE80211_STA_NONE);
1396                 if (ret)
1397                         return ret;
1398         }
1399
1400         return 0;
1401 }
1402
1403 static void sta_apply_mesh_params(struct ieee80211_local *local,
1404                                   struct sta_info *sta,
1405                                   struct station_parameters *params)
1406 {
1407 #ifdef CONFIG_MAC80211_MESH
1408         struct ieee80211_sub_if_data *sdata = sta->sdata;
1409         u32 changed = 0;
1410
1411         if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE) {
1412                 switch (params->plink_state) {
1413                 case NL80211_PLINK_ESTAB:
1414                         if (sta->mesh->plink_state != NL80211_PLINK_ESTAB)
1415                                 changed = mesh_plink_inc_estab_count(sdata);
1416                         sta->mesh->plink_state = params->plink_state;
1417                         sta->mesh->aid = params->peer_aid;
1418
1419                         ieee80211_mps_sta_status_update(sta);
1420                         changed |= ieee80211_mps_set_sta_local_pm(sta,
1421                                       sdata->u.mesh.mshcfg.power_mode);
1422
1423                         ewma_mesh_tx_rate_avg_init(&sta->mesh->tx_rate_avg);
1424                         /* init at low value */
1425                         ewma_mesh_tx_rate_avg_add(&sta->mesh->tx_rate_avg, 10);
1426
1427                         break;
1428                 case NL80211_PLINK_LISTEN:
1429                 case NL80211_PLINK_BLOCKED:
1430                 case NL80211_PLINK_OPN_SNT:
1431                 case NL80211_PLINK_OPN_RCVD:
1432                 case NL80211_PLINK_CNF_RCVD:
1433                 case NL80211_PLINK_HOLDING:
1434                         if (sta->mesh->plink_state == NL80211_PLINK_ESTAB)
1435                                 changed = mesh_plink_dec_estab_count(sdata);
1436                         sta->mesh->plink_state = params->plink_state;
1437
1438                         ieee80211_mps_sta_status_update(sta);
1439                         changed |= ieee80211_mps_set_sta_local_pm(sta,
1440                                         NL80211_MESH_POWER_UNKNOWN);
1441                         break;
1442                 default:
1443                         /*  nothing  */
1444                         break;
1445                 }
1446         }
1447
1448         switch (params->plink_action) {
1449         case NL80211_PLINK_ACTION_NO_ACTION:
1450                 /* nothing */
1451                 break;
1452         case NL80211_PLINK_ACTION_OPEN:
1453                 changed |= mesh_plink_open(sta);
1454                 break;
1455         case NL80211_PLINK_ACTION_BLOCK:
1456                 changed |= mesh_plink_block(sta);
1457                 break;
1458         }
1459
1460         if (params->local_pm)
1461                 changed |= ieee80211_mps_set_sta_local_pm(sta,
1462                                                           params->local_pm);
1463
1464         ieee80211_mbss_info_change_notify(sdata, changed);
1465 #endif
1466 }
1467
1468 static int sta_apply_parameters(struct ieee80211_local *local,
1469                                 struct sta_info *sta,
1470                                 struct station_parameters *params)
1471 {
1472         int ret = 0;
1473         struct ieee80211_supported_band *sband;
1474         struct ieee80211_sub_if_data *sdata = sta->sdata;
1475         u32 mask, set;
1476
1477         sband = ieee80211_get_sband(sdata);
1478         if (!sband)
1479                 return -EINVAL;
1480
1481         mask = params->sta_flags_mask;
1482         set = params->sta_flags_set;
1483
1484         if (ieee80211_vif_is_mesh(&sdata->vif)) {
1485                 /*
1486                  * In mesh mode, ASSOCIATED isn't part of the nl80211
1487                  * API but must follow AUTHENTICATED for driver state.
1488                  */
1489                 if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED))
1490                         mask |= BIT(NL80211_STA_FLAG_ASSOCIATED);
1491                 if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED))
1492                         set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
1493         } else if (test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
1494                 /*
1495                  * TDLS -- everything follows authorized, but
1496                  * only becoming authorized is possible, not
1497                  * going back
1498                  */
1499                 if (set & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1500                         set |= BIT(NL80211_STA_FLAG_AUTHENTICATED) |
1501                                BIT(NL80211_STA_FLAG_ASSOCIATED);
1502                         mask |= BIT(NL80211_STA_FLAG_AUTHENTICATED) |
1503                                 BIT(NL80211_STA_FLAG_ASSOCIATED);
1504                 }
1505         }
1506
1507         if (mask & BIT(NL80211_STA_FLAG_WME) &&
1508             local->hw.queues >= IEEE80211_NUM_ACS)
1509                 sta->sta.wme = set & BIT(NL80211_STA_FLAG_WME);
1510
1511         /* auth flags will be set later for TDLS,
1512          * and for unassociated stations that move to assocaited */
1513         if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
1514             !((mask & BIT(NL80211_STA_FLAG_ASSOCIATED)) &&
1515               (set & BIT(NL80211_STA_FLAG_ASSOCIATED)))) {
1516                 ret = sta_apply_auth_flags(local, sta, mask, set);
1517                 if (ret)
1518                         return ret;
1519         }
1520
1521         if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
1522                 if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
1523                         set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1524                 else
1525                         clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1526         }
1527
1528         if (mask & BIT(NL80211_STA_FLAG_MFP)) {
1529                 sta->sta.mfp = !!(set & BIT(NL80211_STA_FLAG_MFP));
1530                 if (set & BIT(NL80211_STA_FLAG_MFP))
1531                         set_sta_flag(sta, WLAN_STA_MFP);
1532                 else
1533                         clear_sta_flag(sta, WLAN_STA_MFP);
1534         }
1535
1536         if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
1537                 if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
1538                         set_sta_flag(sta, WLAN_STA_TDLS_PEER);
1539                 else
1540                         clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
1541         }
1542
1543         /* mark TDLS channel switch support, if the AP allows it */
1544         if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
1545             !sdata->u.mgd.tdls_chan_switch_prohibited &&
1546             params->ext_capab_len >= 4 &&
1547             params->ext_capab[3] & WLAN_EXT_CAPA4_TDLS_CHAN_SWITCH)
1548                 set_sta_flag(sta, WLAN_STA_TDLS_CHAN_SWITCH);
1549
1550         if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
1551             !sdata->u.mgd.tdls_wider_bw_prohibited &&
1552             ieee80211_hw_check(&local->hw, TDLS_WIDER_BW) &&
1553             params->ext_capab_len >= 8 &&
1554             params->ext_capab[7] & WLAN_EXT_CAPA8_TDLS_WIDE_BW_ENABLED)
1555                 set_sta_flag(sta, WLAN_STA_TDLS_WIDER_BW);
1556
1557         if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
1558                 sta->sta.uapsd_queues = params->uapsd_queues;
1559                 sta->sta.max_sp = params->max_sp;
1560         }
1561
1562         /* The sender might not have sent the last bit, consider it to be 0 */
1563         if (params->ext_capab_len >= 8) {
1564                 u8 val = (params->ext_capab[7] &
1565                           WLAN_EXT_CAPA8_MAX_MSDU_IN_AMSDU_LSB) >> 7;
1566
1567                 /* we did get all the bits, take the MSB as well */
1568                 if (params->ext_capab_len >= 9) {
1569                         u8 val_msb = params->ext_capab[8] &
1570                                 WLAN_EXT_CAPA9_MAX_MSDU_IN_AMSDU_MSB;
1571                         val_msb <<= 1;
1572                         val |= val_msb;
1573                 }
1574
1575                 switch (val) {
1576                 case 1:
1577                         sta->sta.max_amsdu_subframes = 32;
1578                         break;
1579                 case 2:
1580                         sta->sta.max_amsdu_subframes = 16;
1581                         break;
1582                 case 3:
1583                         sta->sta.max_amsdu_subframes = 8;
1584                         break;
1585                 default:
1586                         sta->sta.max_amsdu_subframes = 0;
1587                 }
1588         }
1589
1590         /*
1591          * cfg80211 validates this (1-2007) and allows setting the AID
1592          * only when creating a new station entry
1593          */
1594         if (params->aid)
1595                 sta->sta.aid = params->aid;
1596
1597         /*
1598          * Some of the following updates would be racy if called on an
1599          * existing station, via ieee80211_change_station(). However,
1600          * all such changes are rejected by cfg80211 except for updates
1601          * changing the supported rates on an existing but not yet used
1602          * TDLS peer.
1603          */
1604
1605         if (params->listen_interval >= 0)
1606                 sta->listen_interval = params->listen_interval;
1607
1608         if (params->sta_modify_mask & STATION_PARAM_APPLY_STA_TXPOWER) {
1609                 sta->sta.txpwr.type = params->txpwr.type;
1610                 if (params->txpwr.type == NL80211_TX_POWER_LIMITED)
1611                         sta->sta.txpwr.power = params->txpwr.power;
1612                 ret = drv_sta_set_txpwr(local, sdata, sta);
1613                 if (ret)
1614                         return ret;
1615         }
1616
1617         if (params->supported_rates && params->supported_rates_len) {
1618                 ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
1619                                          sband, params->supported_rates,
1620                                          params->supported_rates_len,
1621                                          &sta->sta.supp_rates[sband->band]);
1622         }
1623
1624         if (params->ht_capa)
1625                 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1626                                                   params->ht_capa, sta);
1627
1628         /* VHT can override some HT caps such as the A-MSDU max length */
1629         if (params->vht_capa)
1630                 ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1631                                                     params->vht_capa, sta);
1632
1633         if (params->he_capa)
1634                 ieee80211_he_cap_ie_to_sta_he_cap(sdata, sband,
1635                                                   (void *)params->he_capa,
1636                                                   params->he_capa_len,
1637                                                   (void *)params->he_6ghz_capa,
1638                                                   sta);
1639
1640         if (params->opmode_notif_used) {
1641                 /* returned value is only needed for rc update, but the
1642                  * rc isn't initialized here yet, so ignore it
1643                  */
1644                 __ieee80211_vht_handle_opmode(sdata, sta, params->opmode_notif,
1645                                               sband->band);
1646         }
1647
1648         if (params->support_p2p_ps >= 0)
1649                 sta->sta.support_p2p_ps = params->support_p2p_ps;
1650
1651         if (ieee80211_vif_is_mesh(&sdata->vif))
1652                 sta_apply_mesh_params(local, sta, params);
1653
1654         if (params->airtime_weight)
1655                 sta->airtime_weight = params->airtime_weight;
1656
1657         /* set the STA state after all sta info from usermode has been set */
1658         if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) ||
1659             set & BIT(NL80211_STA_FLAG_ASSOCIATED)) {
1660                 ret = sta_apply_auth_flags(local, sta, mask, set);
1661                 if (ret)
1662                         return ret;
1663         }
1664
1665         return 0;
1666 }
1667
1668 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
1669                                  const u8 *mac,
1670                                  struct station_parameters *params)
1671 {
1672         struct ieee80211_local *local = wiphy_priv(wiphy);
1673         struct sta_info *sta;
1674         struct ieee80211_sub_if_data *sdata;
1675         int err;
1676
1677         if (params->vlan) {
1678                 sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
1679
1680                 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1681                     sdata->vif.type != NL80211_IFTYPE_AP)
1682                         return -EINVAL;
1683         } else
1684                 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1685
1686         if (ether_addr_equal(mac, sdata->vif.addr))
1687                 return -EINVAL;
1688
1689         if (!is_valid_ether_addr(mac))
1690                 return -EINVAL;
1691
1692         if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER) &&
1693             sdata->vif.type == NL80211_IFTYPE_STATION &&
1694             !sdata->u.mgd.associated)
1695                 return -EINVAL;
1696
1697         sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
1698         if (!sta)
1699                 return -ENOMEM;
1700
1701         if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
1702                 sta->sta.tdls = true;
1703
1704         err = sta_apply_parameters(local, sta, params);
1705         if (err) {
1706                 sta_info_free(local, sta);
1707                 return err;
1708         }
1709
1710         /*
1711          * for TDLS and for unassociated station, rate control should be
1712          * initialized only when rates are known and station is marked
1713          * authorized/associated
1714          */
1715         if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
1716             test_sta_flag(sta, WLAN_STA_ASSOC))
1717                 rate_control_rate_init(sta);
1718
1719         err = sta_info_insert_rcu(sta);
1720         if (err) {
1721                 rcu_read_unlock();
1722                 return err;
1723         }
1724
1725         rcu_read_unlock();
1726
1727         return 0;
1728 }
1729
1730 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
1731                                  struct station_del_parameters *params)
1732 {
1733         struct ieee80211_sub_if_data *sdata;
1734
1735         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1736
1737         if (params->mac)
1738                 return sta_info_destroy_addr_bss(sdata, params->mac);
1739
1740         sta_info_flush(sdata);
1741         return 0;
1742 }
1743
1744 static int ieee80211_change_station(struct wiphy *wiphy,
1745                                     struct net_device *dev, const u8 *mac,
1746                                     struct station_parameters *params)
1747 {
1748         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1749         struct ieee80211_local *local = wiphy_priv(wiphy);
1750         struct sta_info *sta;
1751         struct ieee80211_sub_if_data *vlansdata;
1752         enum cfg80211_station_type statype;
1753         int err;
1754
1755         mutex_lock(&local->sta_mtx);
1756
1757         sta = sta_info_get_bss(sdata, mac);
1758         if (!sta) {
1759                 err = -ENOENT;
1760                 goto out_err;
1761         }
1762
1763         switch (sdata->vif.type) {
1764         case NL80211_IFTYPE_MESH_POINT:
1765                 if (sdata->u.mesh.user_mpm)
1766                         statype = CFG80211_STA_MESH_PEER_USER;
1767                 else
1768                         statype = CFG80211_STA_MESH_PEER_KERNEL;
1769                 break;
1770         case NL80211_IFTYPE_ADHOC:
1771                 statype = CFG80211_STA_IBSS;
1772                 break;
1773         case NL80211_IFTYPE_STATION:
1774                 if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
1775                         statype = CFG80211_STA_AP_STA;
1776                         break;
1777                 }
1778                 if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1779                         statype = CFG80211_STA_TDLS_PEER_ACTIVE;
1780                 else
1781                         statype = CFG80211_STA_TDLS_PEER_SETUP;
1782                 break;
1783         case NL80211_IFTYPE_AP:
1784         case NL80211_IFTYPE_AP_VLAN:
1785                 if (test_sta_flag(sta, WLAN_STA_ASSOC))
1786                         statype = CFG80211_STA_AP_CLIENT;
1787                 else
1788                         statype = CFG80211_STA_AP_CLIENT_UNASSOC;
1789                 break;
1790         default:
1791                 err = -EOPNOTSUPP;
1792                 goto out_err;
1793         }
1794
1795         err = cfg80211_check_station_change(wiphy, params, statype);
1796         if (err)
1797                 goto out_err;
1798
1799         if (params->vlan && params->vlan != sta->sdata->dev) {
1800                 vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
1801
1802                 if (params->vlan->ieee80211_ptr->use_4addr) {
1803                         if (vlansdata->u.vlan.sta) {
1804                                 err = -EBUSY;
1805                                 goto out_err;
1806                         }
1807
1808                         rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
1809                         __ieee80211_check_fast_rx_iface(vlansdata);
1810                         drv_sta_set_4addr(local, sta->sdata, &sta->sta, true);
1811                 }
1812
1813                 if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1814                     sta->sdata->u.vlan.sta)
1815                         RCU_INIT_POINTER(sta->sdata->u.vlan.sta, NULL);
1816
1817                 if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1818                         ieee80211_vif_dec_num_mcast(sta->sdata);
1819
1820                 sta->sdata = vlansdata;
1821                 ieee80211_check_fast_rx(sta);
1822                 ieee80211_check_fast_xmit(sta);
1823
1824                 if (test_sta_flag(sta, WLAN_STA_AUTHORIZED)) {
1825                         ieee80211_vif_inc_num_mcast(sta->sdata);
1826                         cfg80211_send_layer2_update(sta->sdata->dev,
1827                                                     sta->sta.addr);
1828                 }
1829         }
1830
1831         err = sta_apply_parameters(local, sta, params);
1832         if (err)
1833                 goto out_err;
1834
1835         mutex_unlock(&local->sta_mtx);
1836
1837         if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1838             params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1839                 ieee80211_recalc_ps(local);
1840                 ieee80211_recalc_ps_vif(sdata);
1841         }
1842
1843         return 0;
1844 out_err:
1845         mutex_unlock(&local->sta_mtx);
1846         return err;
1847 }
1848
1849 #ifdef CONFIG_MAC80211_MESH
1850 static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
1851                                const u8 *dst, const u8 *next_hop)
1852 {
1853         struct ieee80211_sub_if_data *sdata;
1854         struct mesh_path *mpath;
1855         struct sta_info *sta;
1856
1857         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1858
1859         rcu_read_lock();
1860         sta = sta_info_get(sdata, next_hop);
1861         if (!sta) {
1862                 rcu_read_unlock();
1863                 return -ENOENT;
1864         }
1865
1866         mpath = mesh_path_add(sdata, dst);
1867         if (IS_ERR(mpath)) {
1868                 rcu_read_unlock();
1869                 return PTR_ERR(mpath);
1870         }
1871
1872         mesh_path_fix_nexthop(mpath, sta);
1873
1874         rcu_read_unlock();
1875         return 0;
1876 }
1877
1878 static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
1879                                const u8 *dst)
1880 {
1881         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1882
1883         if (dst)
1884                 return mesh_path_del(sdata, dst);
1885
1886         mesh_path_flush_by_iface(sdata);
1887         return 0;
1888 }
1889
1890 static int ieee80211_change_mpath(struct wiphy *wiphy, struct net_device *dev,
1891                                   const u8 *dst, const u8 *next_hop)
1892 {
1893         struct ieee80211_sub_if_data *sdata;
1894         struct mesh_path *mpath;
1895         struct sta_info *sta;
1896
1897         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1898
1899         rcu_read_lock();
1900
1901         sta = sta_info_get(sdata, next_hop);
1902         if (!sta) {
1903                 rcu_read_unlock();
1904                 return -ENOENT;
1905         }
1906
1907         mpath = mesh_path_lookup(sdata, dst);
1908         if (!mpath) {
1909                 rcu_read_unlock();
1910                 return -ENOENT;
1911         }
1912
1913         mesh_path_fix_nexthop(mpath, sta);
1914
1915         rcu_read_unlock();
1916         return 0;
1917 }
1918
1919 static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
1920                             struct mpath_info *pinfo)
1921 {
1922         struct sta_info *next_hop_sta = rcu_dereference(mpath->next_hop);
1923
1924         if (next_hop_sta)
1925                 memcpy(next_hop, next_hop_sta->sta.addr, ETH_ALEN);
1926         else
1927                 eth_zero_addr(next_hop);
1928
1929         memset(pinfo, 0, sizeof(*pinfo));
1930
1931         pinfo->generation = mpath->sdata->u.mesh.mesh_paths_generation;
1932
1933         pinfo->filled = MPATH_INFO_FRAME_QLEN |
1934                         MPATH_INFO_SN |
1935                         MPATH_INFO_METRIC |
1936                         MPATH_INFO_EXPTIME |
1937                         MPATH_INFO_DISCOVERY_TIMEOUT |
1938                         MPATH_INFO_DISCOVERY_RETRIES |
1939                         MPATH_INFO_FLAGS |
1940                         MPATH_INFO_HOP_COUNT |
1941                         MPATH_INFO_PATH_CHANGE;
1942
1943         pinfo->frame_qlen = mpath->frame_queue.qlen;
1944         pinfo->sn = mpath->sn;
1945         pinfo->metric = mpath->metric;
1946         if (time_before(jiffies, mpath->exp_time))
1947                 pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
1948         pinfo->discovery_timeout =
1949                         jiffies_to_msecs(mpath->discovery_timeout);
1950         pinfo->discovery_retries = mpath->discovery_retries;
1951         if (mpath->flags & MESH_PATH_ACTIVE)
1952                 pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
1953         if (mpath->flags & MESH_PATH_RESOLVING)
1954                 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
1955         if (mpath->flags & MESH_PATH_SN_VALID)
1956                 pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
1957         if (mpath->flags & MESH_PATH_FIXED)
1958                 pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
1959         if (mpath->flags & MESH_PATH_RESOLVED)
1960                 pinfo->flags |= NL80211_MPATH_FLAG_RESOLVED;
1961         pinfo->hop_count = mpath->hop_count;
1962         pinfo->path_change_count = mpath->path_change_count;
1963 }
1964
1965 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
1966                                u8 *dst, u8 *next_hop, struct mpath_info *pinfo)
1967
1968 {
1969         struct ieee80211_sub_if_data *sdata;
1970         struct mesh_path *mpath;
1971
1972         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1973
1974         rcu_read_lock();
1975         mpath = mesh_path_lookup(sdata, dst);
1976         if (!mpath) {
1977                 rcu_read_unlock();
1978                 return -ENOENT;
1979         }
1980         memcpy(dst, mpath->dst, ETH_ALEN);
1981         mpath_set_pinfo(mpath, next_hop, pinfo);
1982         rcu_read_unlock();
1983         return 0;
1984 }
1985
1986 static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
1987                                 int idx, u8 *dst, u8 *next_hop,
1988                                 struct mpath_info *pinfo)
1989 {
1990         struct ieee80211_sub_if_data *sdata;
1991         struct mesh_path *mpath;
1992
1993         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1994
1995         rcu_read_lock();
1996         mpath = mesh_path_lookup_by_idx(sdata, idx);
1997         if (!mpath) {
1998                 rcu_read_unlock();
1999                 return -ENOENT;
2000         }
2001         memcpy(dst, mpath->dst, ETH_ALEN);
2002         mpath_set_pinfo(mpath, next_hop, pinfo);
2003         rcu_read_unlock();
2004         return 0;
2005 }
2006
2007 static void mpp_set_pinfo(struct mesh_path *mpath, u8 *mpp,
2008                           struct mpath_info *pinfo)
2009 {
2010         memset(pinfo, 0, sizeof(*pinfo));
2011         memcpy(mpp, mpath->mpp, ETH_ALEN);
2012
2013         pinfo->generation = mpath->sdata->u.mesh.mpp_paths_generation;
2014 }
2015
2016 static int ieee80211_get_mpp(struct wiphy *wiphy, struct net_device *dev,
2017                              u8 *dst, u8 *mpp, struct mpath_info *pinfo)
2018
2019 {
2020         struct ieee80211_sub_if_data *sdata;
2021         struct mesh_path *mpath;
2022
2023         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2024
2025         rcu_read_lock();
2026         mpath = mpp_path_lookup(sdata, dst);
2027         if (!mpath) {
2028                 rcu_read_unlock();
2029                 return -ENOENT;
2030         }
2031         memcpy(dst, mpath->dst, ETH_ALEN);
2032         mpp_set_pinfo(mpath, mpp, pinfo);
2033         rcu_read_unlock();
2034         return 0;
2035 }
2036
2037 static int ieee80211_dump_mpp(struct wiphy *wiphy, struct net_device *dev,
2038                               int idx, u8 *dst, u8 *mpp,
2039                               struct mpath_info *pinfo)
2040 {
2041         struct ieee80211_sub_if_data *sdata;
2042         struct mesh_path *mpath;
2043
2044         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2045
2046         rcu_read_lock();
2047         mpath = mpp_path_lookup_by_idx(sdata, idx);
2048         if (!mpath) {
2049                 rcu_read_unlock();
2050                 return -ENOENT;
2051         }
2052         memcpy(dst, mpath->dst, ETH_ALEN);
2053         mpp_set_pinfo(mpath, mpp, pinfo);
2054         rcu_read_unlock();
2055         return 0;
2056 }
2057
2058 static int ieee80211_get_mesh_config(struct wiphy *wiphy,
2059                                 struct net_device *dev,
2060                                 struct mesh_config *conf)
2061 {
2062         struct ieee80211_sub_if_data *sdata;
2063         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2064
2065         memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
2066         return 0;
2067 }
2068
2069 static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
2070 {
2071         return (mask >> (parm-1)) & 0x1;
2072 }
2073
2074 static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
2075                 const struct mesh_setup *setup)
2076 {
2077         u8 *new_ie;
2078         struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
2079                                         struct ieee80211_sub_if_data, u.mesh);
2080         int i;
2081
2082         /* allocate information elements */
2083         new_ie = NULL;
2084
2085         if (setup->ie_len) {
2086                 new_ie = kmemdup(setup->ie, setup->ie_len,
2087                                 GFP_KERNEL);
2088                 if (!new_ie)
2089                         return -ENOMEM;
2090         }
2091         ifmsh->ie_len = setup->ie_len;
2092         ifmsh->ie = new_ie;
2093
2094         /* now copy the rest of the setup parameters */
2095         ifmsh->mesh_id_len = setup->mesh_id_len;
2096         memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len);
2097         ifmsh->mesh_sp_id = setup->sync_method;
2098         ifmsh->mesh_pp_id = setup->path_sel_proto;
2099         ifmsh->mesh_pm_id = setup->path_metric;
2100         ifmsh->user_mpm = setup->user_mpm;
2101         ifmsh->mesh_auth_id = setup->auth_id;
2102         ifmsh->security = IEEE80211_MESH_SEC_NONE;
2103         ifmsh->userspace_handles_dfs = setup->userspace_handles_dfs;
2104         if (setup->is_authenticated)
2105                 ifmsh->security |= IEEE80211_MESH_SEC_AUTHED;
2106         if (setup->is_secure)
2107                 ifmsh->security |= IEEE80211_MESH_SEC_SECURED;
2108
2109         /* mcast rate setting in Mesh Node */
2110         memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
2111                                                 sizeof(setup->mcast_rate));
2112         sdata->vif.bss_conf.basic_rates = setup->basic_rates;
2113
2114         sdata->vif.bss_conf.beacon_int = setup->beacon_interval;
2115         sdata->vif.bss_conf.dtim_period = setup->dtim_period;
2116
2117         sdata->beacon_rate_set = false;
2118         if (wiphy_ext_feature_isset(sdata->local->hw.wiphy,
2119                                     NL80211_EXT_FEATURE_BEACON_RATE_LEGACY)) {
2120                 for (i = 0; i < NUM_NL80211_BANDS; i++) {
2121                         sdata->beacon_rateidx_mask[i] =
2122                                 setup->beacon_rate.control[i].legacy;
2123                         if (sdata->beacon_rateidx_mask[i])
2124                                 sdata->beacon_rate_set = true;
2125                 }
2126         }
2127
2128         return 0;
2129 }
2130
2131 static int ieee80211_update_mesh_config(struct wiphy *wiphy,
2132                                         struct net_device *dev, u32 mask,
2133                                         const struct mesh_config *nconf)
2134 {
2135         struct mesh_config *conf;
2136         struct ieee80211_sub_if_data *sdata;
2137         struct ieee80211_if_mesh *ifmsh;
2138
2139         sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2140         ifmsh = &sdata->u.mesh;
2141
2142         /* Set the config options which we are interested in setting */
2143         conf = &(sdata->u.mesh.mshcfg);
2144         if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
2145                 conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
2146         if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
2147                 conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
2148         if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
2149                 conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
2150         if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
2151                 conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
2152         if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
2153                 conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
2154         if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
2155                 conf->dot11MeshTTL = nconf->dot11MeshTTL;
2156         if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
2157                 conf->element_ttl = nconf->element_ttl;
2158         if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) {
2159                 if (ifmsh->user_mpm)
2160                         return -EBUSY;
2161                 conf->auto_open_plinks = nconf->auto_open_plinks;
2162         }
2163         if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask))
2164                 conf->dot11MeshNbrOffsetMaxNeighbor =
2165                         nconf->dot11MeshNbrOffsetMaxNeighbor;
2166         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
2167                 conf->dot11MeshHWMPmaxPREQretries =
2168                         nconf->dot11MeshHWMPmaxPREQretries;
2169         if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
2170                 conf->path_refresh_time = nconf->path_refresh_time;
2171         if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
2172                 conf->min_discovery_timeout = nconf->min_discovery_timeout;
2173         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
2174                 conf->dot11MeshHWMPactivePathTimeout =
2175                         nconf->dot11MeshHWMPactivePathTimeout;
2176         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
2177                 conf->dot11MeshHWMPpreqMinInterval =
2178                         nconf->dot11MeshHWMPpreqMinInterval;
2179         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
2180                 conf->dot11MeshHWMPperrMinInterval =
2181                         nconf->dot11MeshHWMPperrMinInterval;
2182         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2183                            mask))
2184                 conf->dot11MeshHWMPnetDiameterTraversalTime =
2185                         nconf->dot11MeshHWMPnetDiameterTraversalTime;
2186         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
2187                 conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
2188                 ieee80211_mesh_root_setup(ifmsh);
2189         }
2190         if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
2191                 /* our current gate announcement implementation rides on root
2192                  * announcements, so require this ifmsh to also be a root node
2193                  * */
2194                 if (nconf->dot11MeshGateAnnouncementProtocol &&
2195                     !(conf->dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)) {
2196                         conf->dot11MeshHWMPRootMode = IEEE80211_PROACTIVE_RANN;
2197                         ieee80211_mesh_root_setup(ifmsh);
2198                 }
2199                 conf->dot11MeshGateAnnouncementProtocol =
2200                         nconf->dot11MeshGateAnnouncementProtocol;
2201         }
2202         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask))
2203                 conf->dot11MeshHWMPRannInterval =
2204                         nconf->dot11MeshHWMPRannInterval;
2205         if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask))
2206                 conf->dot11MeshForwarding = nconf->dot11MeshForwarding;
2207         if (_chg_mesh_attr(NL80211_MESHCONF_RSSI_THRESHOLD, mask)) {
2208                 /* our RSSI threshold implementation is supported only for
2209                  * devices that report signal in dBm.
2210                  */
2211                 if (!ieee80211_hw_check(&sdata->local->hw, SIGNAL_DBM))
2212                         return -ENOTSUPP;
2213                 conf->rssi_threshold = nconf->rssi_threshold;
2214         }
2215         if (_chg_mesh_attr(NL80211_MESHCONF_HT_OPMODE, mask)) {
2216                 conf->ht_opmode = nconf->ht_opmode;
2217                 sdata->vif.bss_conf.ht_operation_mode = nconf->ht_opmode;
2218                 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);
2219         }
2220         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, mask))
2221                 conf->dot11MeshHWMPactivePathToRootTimeout =
2222                         nconf->dot11MeshHWMPactivePathToRootTimeout;
2223         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOT_INTERVAL, mask))
2224                 conf->dot11MeshHWMProotInterval =
2225                         nconf->dot11MeshHWMProotInterval;
2226         if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, mask))
2227                 conf->dot11MeshHWMPconfirmationInterval =
2228                         nconf->dot11MeshHWMPconfirmationInterval;
2229         if (_chg_mesh_attr(NL80211_MESHCONF_POWER_MODE, mask)) {
2230                 conf->power_mode = nconf->power_mode;
2231                 ieee80211_mps_local_status_update(sdata);
2232         }
2233         if (_chg_mesh_attr(NL80211_MESHCONF_AWAKE_WINDOW, mask))
2234                 conf->dot11MeshAwakeWindowDuration =
2235                         nconf->dot11MeshAwakeWindowDuration;
2236         if (_chg_mesh_attr(NL80211_MESHCONF_PLINK_TIMEOUT, mask))
2237                 conf->plink_timeout = nconf->plink_timeout;
2238         if (_chg_mesh_attr(NL80211_MESHCONF_CONNECTED_TO_GATE, mask))
2239                 conf->dot11MeshConnectedToMeshGate =
2240                         nconf->dot11MeshConnectedToMeshGate;
2241         if (_chg_mesh_attr(NL80211_MESHCONF_NOLEARN, mask))
2242                 conf->dot11MeshNolearn = nconf->dot11MeshNolearn;
2243         if (_chg_mesh_attr(NL80211_MESHCONF_CONNECTED_TO_AS, mask))
2244                 conf->dot11MeshConnectedToAuthServer =
2245                         nconf->dot11MeshConnectedToAuthServer;
2246         ieee80211_mbss_info_change_notify(sdata, BSS_CHANGED_BEACON);
2247         return 0;
2248 }
2249
2250 static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev,
2251                                const struct mesh_config *conf,
2252                                const struct mesh_setup *setup)
2253 {
2254         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2255         struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
2256         int err;
2257
2258         memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
2259         err = copy_mesh_setup(ifmsh, setup);
2260         if (err)
2261                 return err;
2262
2263         sdata->control_port_over_nl80211 = setup->control_port_over_nl80211;
2264
2265         /* can mesh use other SMPS modes? */
2266         sdata->smps_mode = IEEE80211_SMPS_OFF;
2267         sdata->needed_rx_chains = sdata->local->rx_chains;
2268
2269         mutex_lock(&sdata->local->mtx);
2270         err = ieee80211_vif_use_channel(sdata, &setup->chandef,
2271                                         IEEE80211_CHANCTX_SHARED);
2272         mutex_unlock(&sdata->local->mtx);
2273         if (err)
2274                 return err;
2275
2276         return ieee80211_start_mesh(sdata);
2277 }
2278
2279 static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev)
2280 {
2281         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2282
2283         ieee80211_stop_mesh(sdata);
2284         mutex_lock(&sdata->local->mtx);
2285         ieee80211_vif_release_channel(sdata);
2286         kfree(sdata->u.mesh.ie);
2287         mutex_unlock(&sdata->local->mtx);
2288
2289         return 0;
2290 }
2291 #endif
2292
2293 static int ieee80211_change_bss(struct wiphy *wiphy,
2294                                 struct net_device *dev,
2295                                 struct bss_parameters *params)
2296 {
2297         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2298         struct ieee80211_supported_band *sband;
2299         u32 changed = 0;
2300
2301         if (!sdata_dereference(sdata->u.ap.beacon, sdata))
2302                 return -ENOENT;
2303
2304         sband = ieee80211_get_sband(sdata);
2305         if (!sband)
2306                 return -EINVAL;
2307
2308         if (params->use_cts_prot >= 0) {
2309                 sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
2310                 changed |= BSS_CHANGED_ERP_CTS_PROT;
2311         }
2312         if (params->use_short_preamble >= 0) {
2313                 sdata->vif.bss_conf.use_short_preamble =
2314                         params->use_short_preamble;
2315                 changed |= BSS_CHANGED_ERP_PREAMBLE;
2316         }
2317
2318         if (!sdata->vif.bss_conf.use_short_slot &&
2319             (sband->band == NL80211_BAND_5GHZ ||
2320              sband->band == NL80211_BAND_6GHZ)) {
2321                 sdata->vif.bss_conf.use_short_slot = true;
2322                 changed |= BSS_CHANGED_ERP_SLOT;
2323         }
2324
2325         if (params->use_short_slot_time >= 0) {
2326                 sdata->vif.bss_conf.use_short_slot =
2327                         params->use_short_slot_time;
2328                 changed |= BSS_CHANGED_ERP_SLOT;
2329         }
2330
2331         if (params->basic_rates) {
2332                 ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
2333                                          wiphy->bands[sband->band],
2334                                          params->basic_rates,
2335                                          params->basic_rates_len,
2336                                          &sdata->vif.bss_conf.basic_rates);
2337                 changed |= BSS_CHANGED_BASIC_RATES;
2338                 ieee80211_check_rate_mask(sdata);
2339         }
2340
2341         if (params->ap_isolate >= 0) {
2342                 if (params->ap_isolate)
2343                         sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
2344                 else
2345                         sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
2346                 ieee80211_check_fast_rx_iface(sdata);
2347         }
2348
2349         if (params->ht_opmode >= 0) {
2350                 sdata->vif.bss_conf.ht_operation_mode =
2351                         (u16) params->ht_opmode;
2352                 changed |= BSS_CHANGED_HT;
2353         }
2354
2355         if (params->p2p_ctwindow >= 0) {
2356                 sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow &=
2357                                         ~IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
2358                 sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
2359                         params->p2p_ctwindow & IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
2360                 changed |= BSS_CHANGED_P2P_PS;
2361         }
2362
2363         if (params->p2p_opp_ps > 0) {
2364                 sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
2365                                         IEEE80211_P2P_OPPPS_ENABLE_BIT;
2366                 changed |= BSS_CHANGED_P2P_PS;
2367         } else if (params->p2p_opp_ps == 0) {
2368                 sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow &=
2369                                         ~IEEE80211_P2P_OPPPS_ENABLE_BIT;
2370                 changed |= BSS_CHANGED_P2P_PS;
2371         }
2372
2373         ieee80211_bss_info_change_notify(sdata, changed);
2374
2375         return 0;
2376 }
2377
2378 static int ieee80211_set_txq_params(struct wiphy *wiphy,
2379                                     struct net_device *dev,
2380                                     struct ieee80211_txq_params *params)
2381 {
2382         struct ieee80211_local *local = wiphy_priv(wiphy);
2383         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2384         struct ieee80211_tx_queue_params p;
2385
2386         if (!local->ops->conf_tx)
2387                 return -EOPNOTSUPP;
2388
2389         if (local->hw.queues < IEEE80211_NUM_ACS)
2390                 return -EOPNOTSUPP;
2391
2392         memset(&p, 0, sizeof(p));
2393         p.aifs = params->aifs;
2394         p.cw_max = params->cwmax;
2395         p.cw_min = params->cwmin;
2396         p.txop = params->txop;
2397
2398         /*
2399          * Setting tx queue params disables u-apsd because it's only
2400          * called in master mode.
2401          */
2402         p.uapsd = false;
2403
2404         ieee80211_regulatory_limit_wmm_params(sdata, &p, params->ac);
2405
2406         sdata->tx_conf[params->ac] = p;
2407         if (drv_conf_tx(local, sdata, params->ac, &p)) {
2408                 wiphy_debug(local->hw.wiphy,
2409                             "failed to set TX queue parameters for AC %d\n",
2410                             params->ac);
2411                 return -EINVAL;
2412         }
2413
2414         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);
2415
2416         return 0;
2417 }
2418
2419 #ifdef CONFIG_PM
2420 static int ieee80211_suspend(struct wiphy *wiphy,
2421                              struct cfg80211_wowlan *wowlan)
2422 {
2423         return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
2424 }
2425
2426 static int ieee80211_resume(struct wiphy *wiphy)
2427 {
2428         return __ieee80211_resume(wiphy_priv(wiphy));
2429 }
2430 #else
2431 #define ieee80211_suspend NULL
2432 #define ieee80211_resume NULL
2433 #endif
2434
2435 static int ieee80211_scan(struct wiphy *wiphy,
2436                           struct cfg80211_scan_request *req)
2437 {
2438         struct ieee80211_sub_if_data *sdata;
2439
2440         sdata = IEEE80211_WDEV_TO_SUB_IF(req->wdev);
2441
2442         switch (ieee80211_vif_type_p2p(&sdata->vif)) {
2443         case NL80211_IFTYPE_STATION:
2444         case NL80211_IFTYPE_ADHOC:
2445         case NL80211_IFTYPE_MESH_POINT:
2446         case NL80211_IFTYPE_P2P_CLIENT:
2447         case NL80211_IFTYPE_P2P_DEVICE:
2448                 break;
2449         case NL80211_IFTYPE_P2P_GO:
2450                 if (sdata->local->ops->hw_scan)
2451                         break;
2452                 /*
2453                  * FIXME: implement NoA while scanning in software,
2454                  * for now fall through to allow scanning only when
2455                  * beaconing hasn't been configured yet
2456                  */
2457                 fallthrough;
2458         case NL80211_IFTYPE_AP:
2459                 /*
2460                  * If the scan has been forced (and the driver supports
2461                  * forcing), don't care about being beaconing already.
2462                  * This will create problems to the attached stations (e.g. all
2463                  * the  frames sent while scanning on other channel will be
2464                  * lost)
2465                  */
2466                 if (sdata->u.ap.beacon &&
2467                     (!(wiphy->features & NL80211_FEATURE_AP_SCAN) ||
2468                      !(req->flags & NL80211_SCAN_FLAG_AP)))
2469                         return -EOPNOTSUPP;
2470                 break;
2471         case NL80211_IFTYPE_NAN:
2472         default:
2473                 return -EOPNOTSUPP;
2474         }
2475
2476         return ieee80211_request_scan(sdata, req);
2477 }
2478
2479 static void ieee80211_abort_scan(struct wiphy *wiphy, struct wireless_dev *wdev)
2480 {
2481         ieee80211_scan_cancel(wiphy_priv(wiphy));
2482 }
2483
2484 static int
2485 ieee80211_sched_scan_start(struct wiphy *wiphy,
2486                            struct net_device *dev,
2487                            struct cfg80211_sched_scan_request *req)
2488 {
2489         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2490
2491         if (!sdata->local->ops->sched_scan_start)
2492                 return -EOPNOTSUPP;
2493
2494         return ieee80211_request_sched_scan_start(sdata, req);
2495 }
2496
2497 static int
2498 ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev,
2499                           u64 reqid)
2500 {
2501         struct ieee80211_local *local = wiphy_priv(wiphy);
2502
2503         if (!local->ops->sched_scan_stop)
2504                 return -EOPNOTSUPP;
2505
2506         return ieee80211_request_sched_scan_stop(local);
2507 }
2508
2509 static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
2510                           struct cfg80211_auth_request *req)
2511 {
2512         return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2513 }
2514
2515 static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
2516                            struct cfg80211_assoc_request *req)
2517 {
2518         return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2519 }
2520
2521 static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
2522                             struct cfg80211_deauth_request *req)
2523 {
2524         return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2525 }
2526
2527 static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
2528                               struct cfg80211_disassoc_request *req)
2529 {
2530         return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2531 }
2532
2533 static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
2534                                struct cfg80211_ibss_params *params)
2535 {
2536         return ieee80211_ibss_join(IEEE80211_DEV_TO_SUB_IF(dev), params);
2537 }
2538
2539 static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
2540 {
2541         return ieee80211_ibss_leave(IEEE80211_DEV_TO_SUB_IF(dev));
2542 }
2543
2544 static int ieee80211_join_ocb(struct wiphy *wiphy, struct net_device *dev,
2545                               struct ocb_setup *setup)
2546 {
2547         return ieee80211_ocb_join(IEEE80211_DEV_TO_SUB_IF(dev), setup);
2548 }
2549
2550 static int ieee80211_leave_ocb(struct wiphy *wiphy, struct net_device *dev)
2551 {
2552         return ieee80211_ocb_leave(IEEE80211_DEV_TO_SUB_IF(dev));
2553 }
2554
2555 static int ieee80211_set_mcast_rate(struct wiphy *wiphy, struct net_device *dev,
2556                                     int rate[NUM_NL80211_BANDS])
2557 {
2558         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2559
2560         memcpy(sdata->vif.bss_conf.mcast_rate, rate,
2561                sizeof(int) * NUM_NL80211_BANDS);
2562
2563         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_MCAST_RATE);
2564
2565         return 0;
2566 }
2567
2568 static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
2569 {
2570         struct ieee80211_local *local = wiphy_priv(wiphy);
2571         int err;
2572
2573         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
2574                 ieee80211_check_fast_xmit_all(local);
2575
2576                 err = drv_set_frag_threshold(local, wiphy->frag_threshold);
2577
2578                 if (err) {
2579                         ieee80211_check_fast_xmit_all(local);
2580                         return err;
2581                 }
2582         }
2583
2584         if ((changed & WIPHY_PARAM_COVERAGE_CLASS) ||
2585             (changed & WIPHY_PARAM_DYN_ACK)) {
2586                 s16 coverage_class;
2587
2588                 coverage_class = changed & WIPHY_PARAM_COVERAGE_CLASS ?
2589                                         wiphy->coverage_class : -1;
2590                 err = drv_set_coverage_class(local, coverage_class);
2591
2592                 if (err)
2593                         return err;
2594         }
2595
2596         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
2597                 err = drv_set_rts_threshold(local, wiphy->rts_threshold);
2598
2599                 if (err)
2600                         return err;
2601         }
2602
2603         if (changed & WIPHY_PARAM_RETRY_SHORT) {
2604                 if (wiphy->retry_short > IEEE80211_MAX_TX_RETRY)
2605                         return -EINVAL;
2606                 local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
2607         }
2608         if (changed & WIPHY_PARAM_RETRY_LONG) {
2609                 if (wiphy->retry_long > IEEE80211_MAX_TX_RETRY)
2610                         return -EINVAL;
2611                 local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
2612         }
2613         if (changed &
2614             (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
2615                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
2616
2617         if (changed & (WIPHY_PARAM_TXQ_LIMIT |
2618                        WIPHY_PARAM_TXQ_MEMORY_LIMIT |
2619                        WIPHY_PARAM_TXQ_QUANTUM))
2620                 ieee80211_txq_set_params(local);
2621
2622         return 0;
2623 }
2624
2625 static int ieee80211_set_tx_power(struct wiphy *wiphy,
2626                                   struct wireless_dev *wdev,
2627                                   enum nl80211_tx_power_setting type, int mbm)
2628 {
2629         struct ieee80211_local *local = wiphy_priv(wiphy);
2630         struct ieee80211_sub_if_data *sdata;
2631         enum nl80211_tx_power_setting txp_type = type;
2632         bool update_txp_type = false;
2633         bool has_monitor = false;
2634
2635         if (wdev) {
2636                 sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2637
2638                 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
2639                         sdata = rtnl_dereference(local->monitor_sdata);
2640                         if (!sdata)
2641                                 return -EOPNOTSUPP;
2642                 }
2643
2644                 switch (type) {
2645                 case NL80211_TX_POWER_AUTOMATIC:
2646                         sdata->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2647                         txp_type = NL80211_TX_POWER_LIMITED;
2648                         break;
2649                 case NL80211_TX_POWER_LIMITED:
2650                 case NL80211_TX_POWER_FIXED:
2651                         if (mbm < 0 || (mbm % 100))
2652                                 return -EOPNOTSUPP;
2653                         sdata->user_power_level = MBM_TO_DBM(mbm);
2654                         break;
2655                 }
2656
2657                 if (txp_type != sdata->vif.bss_conf.txpower_type) {
2658                         update_txp_type = true;
2659                         sdata->vif.bss_conf.txpower_type = txp_type;
2660                 }
2661
2662                 ieee80211_recalc_txpower(sdata, update_txp_type);
2663
2664                 return 0;
2665         }
2666
2667         switch (type) {
2668         case NL80211_TX_POWER_AUTOMATIC:
2669                 local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2670                 txp_type = NL80211_TX_POWER_LIMITED;
2671                 break;
2672         case NL80211_TX_POWER_LIMITED:
2673         case NL80211_TX_POWER_FIXED:
2674                 if (mbm < 0 || (mbm % 100))
2675                         return -EOPNOTSUPP;
2676                 local->user_power_level = MBM_TO_DBM(mbm);
2677                 break;
2678         }
2679
2680         mutex_lock(&local->iflist_mtx);
2681         list_for_each_entry(sdata, &local->interfaces, list) {
2682                 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
2683                         has_monitor = true;
2684                         continue;
2685                 }
2686                 sdata->user_power_level = local->user_power_level;
2687                 if (txp_type != sdata->vif.bss_conf.txpower_type)
2688                         update_txp_type = true;
2689                 sdata->vif.bss_conf.txpower_type = txp_type;
2690         }
2691         list_for_each_entry(sdata, &local->interfaces, list) {
2692                 if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
2693                         continue;
2694                 ieee80211_recalc_txpower(sdata, update_txp_type);
2695         }
2696         mutex_unlock(&local->iflist_mtx);
2697
2698         if (has_monitor) {
2699                 sdata = rtnl_dereference(local->monitor_sdata);
2700                 if (sdata) {
2701                         sdata->user_power_level = local->user_power_level;
2702                         if (txp_type != sdata->vif.bss_conf.txpower_type)
2703                                 update_txp_type = true;
2704                         sdata->vif.bss_conf.txpower_type = txp_type;
2705
2706                         ieee80211_recalc_txpower(sdata, update_txp_type);
2707                 }
2708         }
2709
2710         return 0;
2711 }
2712
2713 static int ieee80211_get_tx_power(struct wiphy *wiphy,
2714                                   struct wireless_dev *wdev,
2715                                   int *dbm)
2716 {
2717         struct ieee80211_local *local = wiphy_priv(wiphy);
2718         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2719
2720         if (local->ops->get_txpower)
2721                 return drv_get_txpower(local, sdata, dbm);
2722
2723         if (!local->use_chanctx)
2724                 *dbm = local->hw.conf.power_level;
2725         else
2726                 *dbm = sdata->vif.bss_conf.txpower;
2727
2728         /* INT_MIN indicates no power level was set yet */
2729         if (*dbm == INT_MIN)
2730                 return -EINVAL;
2731
2732         return 0;
2733 }
2734
2735 static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
2736                                   const u8 *addr)
2737 {
2738         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2739
2740         memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN);
2741
2742         return 0;
2743 }
2744
2745 static void ieee80211_rfkill_poll(struct wiphy *wiphy)
2746 {
2747         struct ieee80211_local *local = wiphy_priv(wiphy);
2748
2749         drv_rfkill_poll(local);
2750 }
2751
2752 #ifdef CONFIG_NL80211_TESTMODE
2753 static int ieee80211_testmode_cmd(struct wiphy *wiphy,
2754                                   struct wireless_dev *wdev,
2755                                   void *data, int len)
2756 {
2757         struct ieee80211_local *local = wiphy_priv(wiphy);
2758         struct ieee80211_vif *vif = NULL;
2759
2760         if (!local->ops->testmode_cmd)
2761                 return -EOPNOTSUPP;
2762
2763         if (wdev) {
2764                 struct ieee80211_sub_if_data *sdata;
2765
2766                 sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2767                 if (sdata->flags & IEEE80211_SDATA_IN_DRIVER)
2768                         vif = &sdata->vif;
2769         }
2770
2771         return local->ops->testmode_cmd(&local->hw, vif, data, len);
2772 }
2773
2774 static int ieee80211_testmode_dump(struct wiphy *wiphy,
2775                                    struct sk_buff *skb,
2776                                    struct netlink_callback *cb,
2777                                    void *data, int len)
2778 {
2779         struct ieee80211_local *local = wiphy_priv(wiphy);
2780
2781         if (!local->ops->testmode_dump)
2782                 return -EOPNOTSUPP;
2783
2784         return local->ops->testmode_dump(&local->hw, skb, cb, data, len);
2785 }
2786 #endif
2787
2788 int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
2789                                  enum ieee80211_smps_mode smps_mode)
2790 {
2791         const u8 *ap;
2792         enum ieee80211_smps_mode old_req;
2793         int err;
2794         struct sta_info *sta;
2795         bool tdls_peer_found = false;
2796
2797         lockdep_assert_held(&sdata->wdev.mtx);
2798
2799         if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION))
2800                 return -EINVAL;
2801
2802         old_req = sdata->u.mgd.req_smps;
2803         sdata->u.mgd.req_smps = smps_mode;
2804
2805         if (old_req == smps_mode &&
2806             smps_mode != IEEE80211_SMPS_AUTOMATIC)
2807                 return 0;
2808
2809         /*
2810          * If not associated, or current association is not an HT
2811          * association, there's no need to do anything, just store
2812          * the new value until we associate.
2813          */
2814         if (!sdata->u.mgd.associated ||
2815             sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
2816                 return 0;
2817
2818         ap = sdata->u.mgd.associated->bssid;
2819
2820         rcu_read_lock();
2821         list_for_each_entry_rcu(sta, &sdata->local->sta_list, list) {
2822                 if (!sta->sta.tdls || sta->sdata != sdata || !sta->uploaded ||
2823                     !test_sta_flag(sta, WLAN_STA_AUTHORIZED))
2824                         continue;
2825
2826                 tdls_peer_found = true;
2827                 break;
2828         }
2829         rcu_read_unlock();
2830
2831         if (smps_mode == IEEE80211_SMPS_AUTOMATIC) {
2832                 if (tdls_peer_found || !sdata->u.mgd.powersave)
2833                         smps_mode = IEEE80211_SMPS_OFF;
2834                 else
2835                         smps_mode = IEEE80211_SMPS_DYNAMIC;
2836         }
2837
2838         /* send SM PS frame to AP */
2839         err = ieee80211_send_smps_action(sdata, smps_mode,
2840                                          ap, ap);
2841         if (err)
2842                 sdata->u.mgd.req_smps = old_req;
2843         else if (smps_mode != IEEE80211_SMPS_OFF && tdls_peer_found)
2844                 ieee80211_teardown_tdls_peers(sdata);
2845
2846         return err;
2847 }
2848
2849 static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
2850                                     bool enabled, int timeout)
2851 {
2852         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2853         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2854
2855         if (sdata->vif.type != NL80211_IFTYPE_STATION)
2856                 return -EOPNOTSUPP;
2857
2858         if (!ieee80211_hw_check(&local->hw, SUPPORTS_PS))
2859                 return -EOPNOTSUPP;
2860
2861         if (enabled == sdata->u.mgd.powersave &&
2862             timeout == local->dynamic_ps_forced_timeout)
2863                 return 0;
2864
2865         sdata->u.mgd.powersave = enabled;
2866         local->dynamic_ps_forced_timeout = timeout;
2867
2868         /* no change, but if automatic follow powersave */
2869         sdata_lock(sdata);
2870         __ieee80211_request_smps_mgd(sdata, sdata->u.mgd.req_smps);
2871         sdata_unlock(sdata);
2872
2873         if (ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS))
2874                 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
2875
2876         ieee80211_recalc_ps(local);
2877         ieee80211_recalc_ps_vif(sdata);
2878         ieee80211_check_fast_rx_iface(sdata);
2879
2880         return 0;
2881 }
2882
2883 static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy,
2884                                          struct net_device *dev,
2885                                          s32 rssi_thold, u32 rssi_hyst)
2886 {
2887         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2888         struct ieee80211_vif *vif = &sdata->vif;
2889         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
2890
2891         if (rssi_thold == bss_conf->cqm_rssi_thold &&
2892             rssi_hyst == bss_conf->cqm_rssi_hyst)
2893                 return 0;
2894
2895         if (sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER &&
2896             !(sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI))
2897                 return -EOPNOTSUPP;
2898
2899         bss_conf->cqm_rssi_thold = rssi_thold;
2900         bss_conf->cqm_rssi_hyst = rssi_hyst;
2901         bss_conf->cqm_rssi_low = 0;
2902         bss_conf->cqm_rssi_high = 0;
2903         sdata->u.mgd.last_cqm_event_signal = 0;
2904
2905         /* tell the driver upon association, unless already associated */
2906         if (sdata->u.mgd.associated &&
2907             sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
2908                 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);
2909
2910         return 0;
2911 }
2912
2913 static int ieee80211_set_cqm_rssi_range_config(struct wiphy *wiphy,
2914                                                struct net_device *dev,
2915                                                s32 rssi_low, s32 rssi_high)
2916 {
2917         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2918         struct ieee80211_vif *vif = &sdata->vif;
2919         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
2920
2921         if (sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)
2922                 return -EOPNOTSUPP;
2923
2924         bss_conf->cqm_rssi_low = rssi_low;
2925         bss_conf->cqm_rssi_high = rssi_high;
2926         bss_conf->cqm_rssi_thold = 0;
2927         bss_conf->cqm_rssi_hyst = 0;
2928         sdata->u.mgd.last_cqm_event_signal = 0;
2929
2930         /* tell the driver upon association, unless already associated */
2931         if (sdata->u.mgd.associated &&
2932             sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
2933                 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);
2934
2935         return 0;
2936 }
2937
2938 static int ieee80211_set_bitrate_mask(struct wiphy *wiphy,
2939                                       struct net_device *dev,
2940                                       const u8 *addr,
2941                                       const struct cfg80211_bitrate_mask *mask)
2942 {
2943         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2944         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2945         int i, ret;
2946
2947         if (!ieee80211_sdata_running(sdata))
2948                 return -ENETDOWN;
2949
2950         /*
2951          * If active validate the setting and reject it if it doesn't leave
2952          * at least one basic rate usable, since we really have to be able
2953          * to send something, and if we're an AP we have to be able to do
2954          * so at a basic rate so that all clients can receive it.
2955          */
2956         if (rcu_access_pointer(sdata->vif.chanctx_conf) &&
2957             sdata->vif.bss_conf.chandef.chan) {
2958                 u32 basic_rates = sdata->vif.bss_conf.basic_rates;
2959                 enum nl80211_band band = sdata->vif.bss_conf.chandef.chan->band;
2960
2961                 if (!(mask->control[band].legacy & basic_rates))
2962                         return -EINVAL;
2963         }
2964
2965         if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL)) {
2966                 ret = drv_set_bitrate_mask(local, sdata, mask);
2967                 if (ret)
2968                         return ret;
2969         }
2970
2971         for (i = 0; i < NUM_NL80211_BANDS; i++) {
2972                 struct ieee80211_supported_band *sband = wiphy->bands[i];
2973                 int j;
2974
2975                 sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
2976                 memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].ht_mcs,
2977                        sizeof(mask->control[i].ht_mcs));
2978                 memcpy(sdata->rc_rateidx_vht_mcs_mask[i],
2979                        mask->control[i].vht_mcs,
2980                        sizeof(mask->control[i].vht_mcs));
2981
2982                 sdata->rc_has_mcs_mask[i] = false;
2983                 sdata->rc_has_vht_mcs_mask[i] = false;
2984                 if (!sband)
2985                         continue;
2986
2987                 for (j = 0; j < IEEE80211_HT_MCS_MASK_LEN; j++) {
2988                         if (sdata->rc_rateidx_mcs_mask[i][j] != 0xff) {
2989                                 sdata->rc_has_mcs_mask[i] = true;
2990                                 break;
2991                         }
2992                 }
2993
2994                 for (j = 0; j < NL80211_VHT_NSS_MAX; j++) {
2995                         if (sdata->rc_rateidx_vht_mcs_mask[i][j] != 0xffff) {
2996                                 sdata->rc_has_vht_mcs_mask[i] = true;
2997                                 break;
2998                         }
2999                 }
3000         }
3001
3002         return 0;
3003 }
3004
3005 static int ieee80211_start_radar_detection(struct wiphy *wiphy,
3006                                            struct net_device *dev,
3007                                            struct cfg80211_chan_def *chandef,
3008                                            u32 cac_time_ms)
3009 {
3010         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3011         struct ieee80211_local *local = sdata->local;
3012         int err;
3013
3014         mutex_lock(&local->mtx);
3015         if (!list_empty(&local->roc_list) || local->scanning) {
3016                 err = -EBUSY;
3017                 goto out_unlock;
3018         }
3019
3020         /* whatever, but channel contexts should not complain about that one */
3021         sdata->smps_mode = IEEE80211_SMPS_OFF;
3022         sdata->needed_rx_chains = local->rx_chains;
3023
3024         err = ieee80211_vif_use_channel(sdata, chandef,
3025                                         IEEE80211_CHANCTX_SHARED);
3026         if (err)
3027                 goto out_unlock;
3028
3029         ieee80211_queue_delayed_work(&sdata->local->hw,
3030                                      &sdata->dfs_cac_timer_work,
3031                                      msecs_to_jiffies(cac_time_ms));
3032
3033  out_unlock:
3034         mutex_unlock(&local->mtx);
3035         return err;
3036 }
3037
3038 static void ieee80211_end_cac(struct wiphy *wiphy,
3039                               struct net_device *dev)
3040 {
3041         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3042         struct ieee80211_local *local = sdata->local;
3043
3044         mutex_lock(&local->mtx);
3045         list_for_each_entry(sdata, &local->interfaces, list) {
3046                 /* it might be waiting for the local->mtx, but then
3047                  * by the time it gets it, sdata->wdev.cac_started
3048                  * will no longer be true
3049                  */
3050                 cancel_delayed_work(&sdata->dfs_cac_timer_work);
3051
3052                 if (sdata->wdev.cac_started) {
3053                         ieee80211_vif_release_channel(sdata);
3054                         sdata->wdev.cac_started = false;
3055                 }
3056         }
3057         mutex_unlock(&local->mtx);
3058 }
3059
3060 static struct cfg80211_beacon_data *
3061 cfg80211_beacon_dup(struct cfg80211_beacon_data *beacon)
3062 {
3063         struct cfg80211_beacon_data *new_beacon;
3064         u8 *pos;
3065         int len;
3066
3067         len = beacon->head_len + beacon->tail_len + beacon->beacon_ies_len +
3068               beacon->proberesp_ies_len + beacon->assocresp_ies_len +
3069               beacon->probe_resp_len + beacon->lci_len + beacon->civicloc_len;
3070
3071         new_beacon = kzalloc(sizeof(*new_beacon) + len, GFP_KERNEL);
3072         if (!new_beacon)
3073                 return NULL;
3074
3075         pos = (u8 *)(new_beacon + 1);
3076         if (beacon->head_len) {
3077                 new_beacon->head_len = beacon->head_len;
3078                 new_beacon->head = pos;
3079                 memcpy(pos, beacon->head, beacon->head_len);
3080                 pos += beacon->head_len;
3081         }
3082         if (beacon->tail_len) {
3083                 new_beacon->tail_len = beacon->tail_len;
3084                 new_beacon->tail = pos;
3085                 memcpy(pos, beacon->tail, beacon->tail_len);
3086                 pos += beacon->tail_len;
3087         }
3088         if (beacon->beacon_ies_len) {
3089                 new_beacon->beacon_ies_len = beacon->beacon_ies_len;
3090                 new_beacon->beacon_ies = pos;
3091                 memcpy(pos, beacon->beacon_ies, beacon->beacon_ies_len);
3092                 pos += beacon->beacon_ies_len;
3093         }
3094         if (beacon->proberesp_ies_len) {
3095                 new_beacon->proberesp_ies_len = beacon->proberesp_ies_len;
3096                 new_beacon->proberesp_ies = pos;
3097                 memcpy(pos, beacon->proberesp_ies, beacon->proberesp_ies_len);
3098                 pos += beacon->proberesp_ies_len;
3099         }
3100         if (beacon->assocresp_ies_len) {
3101                 new_beacon->assocresp_ies_len = beacon->assocresp_ies_len;
3102                 new_beacon->assocresp_ies = pos;
3103                 memcpy(pos, beacon->assocresp_ies, beacon->assocresp_ies_len);
3104                 pos += beacon->assocresp_ies_len;
3105         }
3106         if (beacon->probe_resp_len) {
3107                 new_beacon->probe_resp_len = beacon->probe_resp_len;
3108                 new_beacon->probe_resp = pos;
3109                 memcpy(pos, beacon->probe_resp, beacon->probe_resp_len);
3110                 pos += beacon->probe_resp_len;
3111         }
3112
3113         /* might copy -1, meaning no changes requested */
3114         new_beacon->ftm_responder = beacon->ftm_responder;
3115         if (beacon->lci) {
3116                 new_beacon->lci_len = beacon->lci_len;
3117                 new_beacon->lci = pos;
3118                 memcpy(pos, beacon->lci, beacon->lci_len);
3119                 pos += beacon->lci_len;
3120         }
3121         if (beacon->civicloc) {
3122                 new_beacon->civicloc_len = beacon->civicloc_len;
3123                 new_beacon->civicloc = pos;
3124                 memcpy(pos, beacon->civicloc, beacon->civicloc_len);
3125                 pos += beacon->civicloc_len;
3126         }
3127
3128         return new_beacon;
3129 }
3130
3131 void ieee80211_csa_finish(struct ieee80211_vif *vif)
3132 {
3133         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3134
3135         ieee80211_queue_work(&sdata->local->hw,
3136                              &sdata->csa_finalize_work);
3137 }
3138 EXPORT_SYMBOL(ieee80211_csa_finish);
3139
3140 static int ieee80211_set_after_csa_beacon(struct ieee80211_sub_if_data *sdata,
3141                                           u32 *changed)
3142 {
3143         int err;
3144
3145         switch (sdata->vif.type) {
3146         case NL80211_IFTYPE_AP:
3147                 err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon,
3148                                               NULL);
3149                 kfree(sdata->u.ap.next_beacon);
3150                 sdata->u.ap.next_beacon = NULL;
3151
3152                 if (err < 0)
3153                         return err;
3154                 *changed |= err;
3155                 break;
3156         case NL80211_IFTYPE_ADHOC:
3157                 err = ieee80211_ibss_finish_csa(sdata);
3158                 if (err < 0)
3159                         return err;
3160                 *changed |= err;
3161                 break;
3162 #ifdef CONFIG_MAC80211_MESH
3163         case NL80211_IFTYPE_MESH_POINT:
3164                 err = ieee80211_mesh_finish_csa(sdata);
3165                 if (err < 0)
3166                         return err;
3167                 *changed |= err;
3168                 break;
3169 #endif
3170         default:
3171                 WARN_ON(1);
3172                 return -EINVAL;
3173         }
3174
3175         return 0;
3176 }
3177
3178 static int __ieee80211_csa_finalize(struct ieee80211_sub_if_data *sdata)
3179 {
3180         struct ieee80211_local *local = sdata->local;
3181         u32 changed = 0;
3182         int err;
3183
3184         sdata_assert_lock(sdata);
3185         lockdep_assert_held(&local->mtx);
3186         lockdep_assert_held(&local->chanctx_mtx);
3187
3188         /*
3189          * using reservation isn't immediate as it may be deferred until later
3190          * with multi-vif. once reservation is complete it will re-schedule the
3191          * work with no reserved_chanctx so verify chandef to check if it
3192          * completed successfully
3193          */
3194
3195         if (sdata->reserved_chanctx) {
3196                 /*
3197                  * with multi-vif csa driver may call ieee80211_csa_finish()
3198                  * many times while waiting for other interfaces to use their
3199                  * reservations
3200                  */
3201                 if (sdata->reserved_ready)
3202                         return 0;
3203
3204                 return ieee80211_vif_use_reserved_context(sdata);
3205         }
3206
3207         if (!cfg80211_chandef_identical(&sdata->vif.bss_conf.chandef,
3208                                         &sdata->csa_chandef))
3209                 return -EINVAL;
3210
3211         sdata->vif.csa_active = false;
3212
3213         err = ieee80211_set_after_csa_beacon(sdata, &changed);
3214         if (err)
3215                 return err;
3216
3217         ieee80211_bss_info_change_notify(sdata, changed);
3218
3219         if (sdata->csa_block_tx) {
3220                 ieee80211_wake_vif_queues(local, sdata,
3221                                           IEEE80211_QUEUE_STOP_REASON_CSA);
3222                 sdata->csa_block_tx = false;
3223         }
3224
3225         err = drv_post_channel_switch(sdata);
3226         if (err)
3227                 return err;
3228
3229         cfg80211_ch_switch_notify(sdata->dev, &sdata->csa_chandef);
3230
3231         return 0;
3232 }
3233
3234 static void ieee80211_csa_finalize(struct ieee80211_sub_if_data *sdata)
3235 {
3236         if (__ieee80211_csa_finalize(sdata)) {
3237                 sdata_info(sdata, "failed to finalize CSA, disconnecting\n");
3238                 cfg80211_stop_iface(sdata->local->hw.wiphy, &sdata->wdev,
3239                                     GFP_KERNEL);
3240         }
3241 }
3242
3243 void ieee80211_csa_finalize_work(struct work_struct *work)
3244 {
3245         struct ieee80211_sub_if_data *sdata =
3246                 container_of(work, struct ieee80211_sub_if_data,
3247                              csa_finalize_work);
3248         struct ieee80211_local *local = sdata->local;
3249
3250         sdata_lock(sdata);
3251         mutex_lock(&local->mtx);
3252         mutex_lock(&local->chanctx_mtx);
3253
3254         /* AP might have been stopped while waiting for the lock. */
3255         if (!sdata->vif.csa_active)
3256                 goto unlock;
3257
3258         if (!ieee80211_sdata_running(sdata))
3259                 goto unlock;
3260
3261         ieee80211_csa_finalize(sdata);
3262
3263 unlock:
3264         mutex_unlock(&local->chanctx_mtx);
3265         mutex_unlock(&local->mtx);
3266         sdata_unlock(sdata);
3267 }
3268
3269 static int ieee80211_set_csa_beacon(struct ieee80211_sub_if_data *sdata,
3270                                     struct cfg80211_csa_settings *params,
3271                                     u32 *changed)
3272 {
3273         struct ieee80211_csa_settings csa = {};
3274         int err;
3275
3276         switch (sdata->vif.type) {
3277         case NL80211_IFTYPE_AP:
3278                 sdata->u.ap.next_beacon =
3279                         cfg80211_beacon_dup(&params->beacon_after);
3280                 if (!sdata->u.ap.next_beacon)
3281                         return -ENOMEM;
3282
3283                 /*
3284                  * With a count of 0, we don't have to wait for any
3285                  * TBTT before switching, so complete the CSA
3286                  * immediately.  In theory, with a count == 1 we
3287                  * should delay the switch until just before the next
3288                  * TBTT, but that would complicate things so we switch
3289                  * immediately too.  If we would delay the switch
3290                  * until the next TBTT, we would have to set the probe
3291                  * response here.
3292                  *
3293                  * TODO: A channel switch with count <= 1 without
3294                  * sending a CSA action frame is kind of useless,
3295                  * because the clients won't know we're changing
3296                  * channels.  The action frame must be implemented
3297                  * either here or in the userspace.
3298                  */
3299                 if (params->count <= 1)
3300                         break;
3301
3302                 if ((params->n_counter_offsets_beacon >
3303                      IEEE80211_MAX_CNTDWN_COUNTERS_NUM) ||
3304                     (params->n_counter_offsets_presp >
3305                      IEEE80211_MAX_CNTDWN_COUNTERS_NUM))
3306                         return -EINVAL;
3307
3308                 csa.counter_offsets_beacon = params->counter_offsets_beacon;
3309                 csa.counter_offsets_presp = params->counter_offsets_presp;
3310                 csa.n_counter_offsets_beacon = params->n_counter_offsets_beacon;
3311                 csa.n_counter_offsets_presp = params->n_counter_offsets_presp;
3312                 csa.count = params->count;
3313
3314                 err = ieee80211_assign_beacon(sdata, &params->beacon_csa, &csa);
3315                 if (err < 0) {
3316                         kfree(sdata->u.ap.next_beacon);
3317                         return err;
3318                 }
3319                 *changed |= err;
3320
3321                 break;
3322         case NL80211_IFTYPE_ADHOC:
3323                 if (!sdata->vif.bss_conf.ibss_joined)
3324                         return -EINVAL;
3325
3326                 if (params->chandef.width != sdata->u.ibss.chandef.width)
3327                         return -EINVAL;
3328
3329                 switch (params->chandef.width) {
3330                 case NL80211_CHAN_WIDTH_40:
3331                         if (cfg80211_get_chandef_type(&params->chandef) !=
3332                             cfg80211_get_chandef_type(&sdata->u.ibss.chandef))
3333                                 return -EINVAL;
3334                 case NL80211_CHAN_WIDTH_5:
3335                 case NL80211_CHAN_WIDTH_10:
3336                 case NL80211_CHAN_WIDTH_20_NOHT:
3337                 case NL80211_CHAN_WIDTH_20:
3338                         break;
3339                 default:
3340                         return -EINVAL;
3341                 }
3342
3343                 /* changes into another band are not supported */
3344                 if (sdata->u.ibss.chandef.chan->band !=
3345                     params->chandef.chan->band)
3346                         return -EINVAL;
3347
3348                 /* see comments in the NL80211_IFTYPE_AP block */
3349                 if (params->count > 1) {
3350                         err = ieee80211_ibss_csa_beacon(sdata, params);
3351                         if (err < 0)
3352                                 return err;
3353                         *changed |= err;
3354                 }
3355
3356                 ieee80211_send_action_csa(sdata, params);
3357
3358                 break;
3359 #ifdef CONFIG_MAC80211_MESH
3360         case NL80211_IFTYPE_MESH_POINT: {
3361                 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
3362
3363                 /* changes into another band are not supported */
3364                 if (sdata->vif.bss_conf.chandef.chan->band !=
3365                     params->chandef.chan->band)
3366                         return -EINVAL;
3367
3368                 if (ifmsh->csa_role == IEEE80211_MESH_CSA_ROLE_NONE) {
3369                         ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_INIT;
3370                         if (!ifmsh->pre_value)
3371                                 ifmsh->pre_value = 1;
3372                         else
3373                                 ifmsh->pre_value++;
3374                 }
3375
3376                 /* see comments in the NL80211_IFTYPE_AP block */
3377                 if (params->count > 1) {
3378                         err = ieee80211_mesh_csa_beacon(sdata, params);
3379                         if (err < 0) {
3380                                 ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_NONE;
3381                                 return err;
3382                         }
3383                         *changed |= err;
3384                 }
3385
3386                 if (ifmsh->csa_role == IEEE80211_MESH_CSA_ROLE_INIT)
3387                         ieee80211_send_action_csa(sdata, params);
3388
3389                 break;
3390                 }
3391 #endif
3392         default:
3393                 return -EOPNOTSUPP;
3394         }
3395
3396         return 0;
3397 }
3398
3399 static int
3400 __ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
3401                            struct cfg80211_csa_settings *params)
3402 {
3403         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3404         struct ieee80211_local *local = sdata->local;
3405         struct ieee80211_channel_switch ch_switch;
3406         struct ieee80211_chanctx_conf *conf;
3407         struct ieee80211_chanctx *chanctx;
3408         u32 changed = 0;
3409         int err;
3410
3411         sdata_assert_lock(sdata);
3412         lockdep_assert_held(&local->mtx);
3413
3414         if (!list_empty(&local->roc_list) || local->scanning)
3415                 return -EBUSY;
3416
3417         if (sdata->wdev.cac_started)
3418                 return -EBUSY;
3419
3420         if (cfg80211_chandef_identical(&params->chandef,
3421                                        &sdata->vif.bss_conf.chandef))
3422                 return -EINVAL;
3423
3424         /* don't allow another channel switch if one is already active. */
3425         if (sdata->vif.csa_active)
3426                 return -EBUSY;
3427
3428         mutex_lock(&local->chanctx_mtx);
3429         conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
3430                                          lockdep_is_held(&local->chanctx_mtx));
3431         if (!conf) {
3432                 err = -EBUSY;
3433                 goto out;
3434         }
3435
3436         if (params->chandef.chan->freq_offset) {
3437                 /* this may work, but is untested */
3438                 err = -EOPNOTSUPP;
3439                 goto out;
3440         }
3441
3442         chanctx = container_of(conf, struct ieee80211_chanctx, conf);
3443
3444         ch_switch.timestamp = 0;
3445         ch_switch.device_timestamp = 0;
3446         ch_switch.block_tx = params->block_tx;
3447         ch_switch.chandef = params->chandef;
3448         ch_switch.count = params->count;
3449
3450         err = drv_pre_channel_switch(sdata, &ch_switch);
3451         if (err)
3452                 goto out;
3453
3454         err = ieee80211_vif_reserve_chanctx(sdata, &params->chandef,
3455                                             chanctx->mode,
3456                                             params->radar_required);
3457         if (err)
3458                 goto out;
3459
3460         /* if reservation is invalid then this will fail */
3461         err = ieee80211_check_combinations(sdata, NULL, chanctx->mode, 0);
3462         if (err) {
3463                 ieee80211_vif_unreserve_chanctx(sdata);
3464                 goto out;
3465         }
3466
3467         err = ieee80211_set_csa_beacon(sdata, params, &changed);
3468         if (err) {
3469                 ieee80211_vif_unreserve_chanctx(sdata);
3470                 goto out;
3471         }
3472
3473         sdata->csa_chandef = params->chandef;
3474         sdata->csa_block_tx = params->block_tx;
3475         sdata->vif.csa_active = true;
3476
3477         if (sdata->csa_block_tx)
3478                 ieee80211_stop_vif_queues(local, sdata,
3479                                           IEEE80211_QUEUE_STOP_REASON_CSA);
3480
3481         cfg80211_ch_switch_started_notify(sdata->dev, &sdata->csa_chandef,
3482                                           params->count);
3483
3484         if (changed) {
3485                 ieee80211_bss_info_change_notify(sdata, changed);
3486                 drv_channel_switch_beacon(sdata, &params->chandef);
3487         } else {
3488                 /* if the beacon didn't change, we can finalize immediately */
3489                 ieee80211_csa_finalize(sdata);
3490         }
3491
3492 out:
3493         mutex_unlock(&local->chanctx_mtx);
3494         return err;
3495 }
3496
3497 int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
3498                              struct cfg80211_csa_settings *params)
3499 {
3500         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3501         struct ieee80211_local *local = sdata->local;
3502         int err;
3503
3504         mutex_lock(&local->mtx);
3505         err = __ieee80211_channel_switch(wiphy, dev, params);
3506         mutex_unlock(&local->mtx);
3507
3508         return err;
3509 }
3510
3511 u64 ieee80211_mgmt_tx_cookie(struct ieee80211_local *local)
3512 {
3513         lockdep_assert_held(&local->mtx);
3514
3515         local->roc_cookie_counter++;
3516
3517         /* wow, you wrapped 64 bits ... more likely a bug */
3518         if (WARN_ON(local->roc_cookie_counter == 0))
3519                 local->roc_cookie_counter++;
3520
3521         return local->roc_cookie_counter;
3522 }
3523
3524 int ieee80211_attach_ack_skb(struct ieee80211_local *local, struct sk_buff *skb,
3525                              u64 *cookie, gfp_t gfp)
3526 {
3527         unsigned long spin_flags;
3528         struct sk_buff *ack_skb;
3529         int id;
3530
3531         ack_skb = skb_copy(skb, gfp);
3532         if (!ack_skb)
3533                 return -ENOMEM;
3534
3535         spin_lock_irqsave(&local->ack_status_lock, spin_flags);
3536         id = idr_alloc(&local->ack_status_frames, ack_skb,
3537                        1, 0x2000, GFP_ATOMIC);
3538         spin_unlock_irqrestore(&local->ack_status_lock, spin_flags);
3539
3540         if (id < 0) {
3541                 kfree_skb(ack_skb);
3542                 return -ENOMEM;
3543         }
3544
3545         IEEE80211_SKB_CB(skb)->ack_frame_id = id;
3546
3547         *cookie = ieee80211_mgmt_tx_cookie(local);
3548         IEEE80211_SKB_CB(ack_skb)->ack.cookie = *cookie;
3549
3550         return 0;
3551 }
3552
3553 static void
3554 ieee80211_update_mgmt_frame_registrations(struct wiphy *wiphy,
3555                                           struct wireless_dev *wdev,
3556                                           struct mgmt_frame_regs *upd)
3557 {
3558         struct ieee80211_local *local = wiphy_priv(wiphy);
3559         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3560         u32 preq_mask = BIT(IEEE80211_STYPE_PROBE_REQ >> 4);
3561         u32 action_mask = BIT(IEEE80211_STYPE_ACTION >> 4);
3562         bool global_change, intf_change;
3563
3564         global_change =
3565                 (local->probe_req_reg != !!(upd->global_stypes & preq_mask)) ||
3566                 (local->rx_mcast_action_reg !=
3567                  !!(upd->global_mcast_stypes & action_mask));
3568         local->probe_req_reg = upd->global_stypes & preq_mask;
3569         local->rx_mcast_action_reg = upd->global_mcast_stypes & action_mask;
3570
3571         intf_change = (sdata->vif.probe_req_reg !=
3572                        !!(upd->interface_stypes & preq_mask)) ||
3573                 (sdata->vif.rx_mcast_action_reg !=
3574                  !!(upd->interface_mcast_stypes & action_mask));
3575         sdata->vif.probe_req_reg = upd->interface_stypes & preq_mask;
3576         sdata->vif.rx_mcast_action_reg =
3577                 upd->interface_mcast_stypes & action_mask;
3578
3579         if (!local->open_count)
3580                 return;
3581
3582         if (intf_change && ieee80211_sdata_running(sdata))
3583                 drv_config_iface_filter(local, sdata,
3584                                         sdata->vif.probe_req_reg ?
3585                                                 FIF_PROBE_REQ : 0,
3586                                         FIF_PROBE_REQ);
3587
3588         if (global_change)
3589                 ieee80211_configure_filter(local);
3590 }
3591
3592 static int ieee80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
3593 {
3594         struct ieee80211_local *local = wiphy_priv(wiphy);
3595
3596         if (local->started)
3597                 return -EOPNOTSUPP;
3598
3599         return drv_set_antenna(local, tx_ant, rx_ant);
3600 }
3601
3602 static int ieee80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant)
3603 {
3604         struct ieee80211_local *local = wiphy_priv(wiphy);
3605
3606         return drv_get_antenna(local, tx_ant, rx_ant);
3607 }
3608
3609 static int ieee80211_set_rekey_data(struct wiphy *wiphy,
3610                                     struct net_device *dev,
3611                                     struct cfg80211_gtk_rekey_data *data)
3612 {
3613         struct ieee80211_local *local = wiphy_priv(wiphy);
3614         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3615
3616         if (!local->ops->set_rekey_data)
3617                 return -EOPNOTSUPP;
3618
3619         drv_set_rekey_data(local, sdata, data);
3620
3621         return 0;
3622 }
3623
3624 static int ieee80211_probe_client(struct wiphy *wiphy, struct net_device *dev,
3625                                   const u8 *peer, u64 *cookie)
3626 {
3627         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3628         struct ieee80211_local *local = sdata->local;
3629         struct ieee80211_qos_hdr *nullfunc;
3630         struct sk_buff *skb;
3631         int size = sizeof(*nullfunc);
3632         __le16 fc;
3633         bool qos;
3634         struct ieee80211_tx_info *info;
3635         struct sta_info *sta;
3636         struct ieee80211_chanctx_conf *chanctx_conf;
3637         enum nl80211_band band;
3638         int ret;
3639
3640         /* the lock is needed to assign the cookie later */
3641         mutex_lock(&local->mtx);
3642
3643         rcu_read_lock();
3644         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3645         if (WARN_ON(!chanctx_conf)) {
3646                 ret = -EINVAL;
3647                 goto unlock;
3648         }
3649         band = chanctx_conf->def.chan->band;
3650         sta = sta_info_get_bss(sdata, peer);
3651         if (sta) {
3652                 qos = sta->sta.wme;
3653         } else {
3654                 ret = -ENOLINK;
3655                 goto unlock;
3656         }
3657
3658         if (qos) {
3659                 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
3660                                  IEEE80211_STYPE_QOS_NULLFUNC |
3661                                  IEEE80211_FCTL_FROMDS);
3662         } else {
3663                 size -= 2;
3664                 fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
3665                                  IEEE80211_STYPE_NULLFUNC |
3666                                  IEEE80211_FCTL_FROMDS);
3667         }
3668
3669         skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
3670         if (!skb) {
3671                 ret = -ENOMEM;
3672                 goto unlock;
3673         }
3674
3675         skb->dev = dev;
3676
3677         skb_reserve(skb, local->hw.extra_tx_headroom);
3678
3679         nullfunc = skb_put(skb, size);
3680         nullfunc->frame_control = fc;
3681         nullfunc->duration_id = 0;
3682         memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
3683         memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
3684         memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
3685         nullfunc->seq_ctrl = 0;
3686
3687         info = IEEE80211_SKB_CB(skb);
3688
3689         info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS |
3690                        IEEE80211_TX_INTFL_NL80211_FRAME_TX;
3691         info->band = band;
3692
3693         skb_set_queue_mapping(skb, IEEE80211_AC_VO);
3694         skb->priority = 7;
3695         if (qos)
3696                 nullfunc->qos_ctrl = cpu_to_le16(7);
3697
3698         ret = ieee80211_attach_ack_skb(local, skb, cookie, GFP_ATOMIC);
3699         if (ret) {
3700                 kfree_skb(skb);
3701                 goto unlock;
3702         }
3703
3704         local_bh_disable();
3705         ieee80211_xmit(sdata, sta, skb);
3706         local_bh_enable();
3707
3708         ret = 0;
3709 unlock:
3710         rcu_read_unlock();
3711         mutex_unlock(&local->mtx);
3712
3713         return ret;
3714 }
3715
3716 static int ieee80211_cfg_get_channel(struct wiphy *wiphy,
3717                                      struct wireless_dev *wdev,
3718                                      struct cfg80211_chan_def *chandef)
3719 {
3720         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3721         struct ieee80211_local *local = wiphy_priv(wiphy);
3722         struct ieee80211_chanctx_conf *chanctx_conf;
3723         int ret = -ENODATA;
3724
3725         rcu_read_lock();
3726         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3727         if (chanctx_conf) {
3728                 *chandef = sdata->vif.bss_conf.chandef;
3729                 ret = 0;
3730         } else if (local->open_count > 0 &&
3731                    local->open_count == local->monitors &&
3732                    sdata->vif.type == NL80211_IFTYPE_MONITOR) {
3733                 if (local->use_chanctx)
3734                         *chandef = local->monitor_chandef;
3735                 else
3736                         *chandef = local->_oper_chandef;
3737                 ret = 0;
3738         }
3739         rcu_read_unlock();
3740
3741         return ret;
3742 }
3743
3744 #ifdef CONFIG_PM
3745 static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
3746 {
3747         drv_set_wakeup(wiphy_priv(wiphy), enabled);
3748 }
3749 #endif
3750
3751 static int ieee80211_set_qos_map(struct wiphy *wiphy,
3752                                  struct net_device *dev,
3753                                  struct cfg80211_qos_map *qos_map)
3754 {
3755         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3756         struct mac80211_qos_map *new_qos_map, *old_qos_map;
3757
3758         if (qos_map) {
3759                 new_qos_map = kzalloc(sizeof(*new_qos_map), GFP_KERNEL);
3760                 if (!new_qos_map)
3761                         return -ENOMEM;
3762                 memcpy(&new_qos_map->qos_map, qos_map, sizeof(*qos_map));
3763         } else {
3764                 /* A NULL qos_map was passed to disable QoS mapping */
3765                 new_qos_map = NULL;
3766         }
3767
3768         old_qos_map = sdata_dereference(sdata->qos_map, sdata);
3769         rcu_assign_pointer(sdata->qos_map, new_qos_map);
3770         if (old_qos_map)
3771                 kfree_rcu(old_qos_map, rcu_head);
3772
3773         return 0;
3774 }
3775
3776 static int ieee80211_set_ap_chanwidth(struct wiphy *wiphy,
3777                                       struct net_device *dev,
3778                                       struct cfg80211_chan_def *chandef)
3779 {
3780         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3781         int ret;
3782         u32 changed = 0;
3783
3784         ret = ieee80211_vif_change_bandwidth(sdata, chandef, &changed);
3785         if (ret == 0)
3786                 ieee80211_bss_info_change_notify(sdata, changed);
3787
3788         return ret;
3789 }
3790
3791 static int ieee80211_add_tx_ts(struct wiphy *wiphy, struct net_device *dev,
3792                                u8 tsid, const u8 *peer, u8 up,
3793                                u16 admitted_time)
3794 {
3795         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3796         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3797         int ac = ieee802_1d_to_ac[up];
3798
3799         if (sdata->vif.type != NL80211_IFTYPE_STATION)
3800                 return -EOPNOTSUPP;
3801
3802         if (!(sdata->wmm_acm & BIT(up)))
3803                 return -EINVAL;
3804
3805         if (ifmgd->tx_tspec[ac].admitted_time)
3806                 return -EBUSY;
3807
3808         if (admitted_time) {
3809                 ifmgd->tx_tspec[ac].admitted_time = 32 * admitted_time;
3810                 ifmgd->tx_tspec[ac].tsid = tsid;
3811                 ifmgd->tx_tspec[ac].up = up;
3812         }
3813
3814         return 0;
3815 }
3816
3817 static int ieee80211_del_tx_ts(struct wiphy *wiphy, struct net_device *dev,
3818                                u8 tsid, const u8 *peer)
3819 {
3820         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3821         struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3822         struct ieee80211_local *local = wiphy_priv(wiphy);
3823         int ac;
3824
3825         for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
3826                 struct ieee80211_sta_tx_tspec *tx_tspec = &ifmgd->tx_tspec[ac];
3827
3828                 /* skip unused entries */
3829                 if (!tx_tspec->admitted_time)
3830                         continue;
3831
3832                 if (tx_tspec->tsid != tsid)
3833                         continue;
3834
3835                 /* due to this new packets will be reassigned to non-ACM ACs */
3836                 tx_tspec->up = -1;
3837
3838                 /* Make sure that all packets have been sent to avoid to
3839                  * restore the QoS params on packets that are still on the
3840                  * queues.
3841                  */
3842                 synchronize_net();
3843                 ieee80211_flush_queues(local, sdata, false);
3844
3845                 /* restore the normal QoS parameters
3846                  * (unconditionally to avoid races)
3847                  */
3848                 tx_tspec->action = TX_TSPEC_ACTION_STOP_DOWNGRADE;
3849                 tx_tspec->downgraded = false;
3850                 ieee80211_sta_handle_tspec_ac_params(sdata);
3851
3852                 /* finally clear all the data */
3853                 memset(tx_tspec, 0, sizeof(*tx_tspec));
3854
3855                 return 0;
3856         }
3857
3858         return -ENOENT;
3859 }
3860
3861 void ieee80211_nan_func_terminated(struct ieee80211_vif *vif,
3862                                    u8 inst_id,
3863                                    enum nl80211_nan_func_term_reason reason,
3864                                    gfp_t gfp)
3865 {
3866         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3867         struct cfg80211_nan_func *func;
3868         u64 cookie;
3869
3870         if (WARN_ON(vif->type != NL80211_IFTYPE_NAN))
3871                 return;
3872
3873         spin_lock_bh(&sdata->u.nan.func_lock);
3874
3875         func = idr_find(&sdata->u.nan.function_inst_ids, inst_id);
3876         if (WARN_ON(!func)) {
3877                 spin_unlock_bh(&sdata->u.nan.func_lock);
3878                 return;
3879         }
3880
3881         cookie = func->cookie;
3882         idr_remove(&sdata->u.nan.function_inst_ids, inst_id);
3883
3884         spin_unlock_bh(&sdata->u.nan.func_lock);
3885
3886         cfg80211_free_nan_func(func);
3887
3888         cfg80211_nan_func_terminated(ieee80211_vif_to_wdev(vif), inst_id,
3889                                      reason, cookie, gfp);
3890 }
3891 EXPORT_SYMBOL(ieee80211_nan_func_terminated);
3892
3893 void ieee80211_nan_func_match(struct ieee80211_vif *vif,
3894                               struct cfg80211_nan_match_params *match,
3895                               gfp_t gfp)
3896 {
3897         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3898         struct cfg80211_nan_func *func;
3899
3900         if (WARN_ON(vif->type != NL80211_IFTYPE_NAN))
3901                 return;
3902
3903         spin_lock_bh(&sdata->u.nan.func_lock);
3904
3905         func = idr_find(&sdata->u.nan.function_inst_ids,  match->inst_id);
3906         if (WARN_ON(!func)) {
3907                 spin_unlock_bh(&sdata->u.nan.func_lock);
3908                 return;
3909         }
3910         match->cookie = func->cookie;
3911
3912         spin_unlock_bh(&sdata->u.nan.func_lock);
3913
3914         cfg80211_nan_match(ieee80211_vif_to_wdev(vif), match, gfp);
3915 }
3916 EXPORT_SYMBOL(ieee80211_nan_func_match);
3917
3918 static int ieee80211_set_multicast_to_unicast(struct wiphy *wiphy,
3919                                               struct net_device *dev,
3920                                               const bool enabled)
3921 {
3922         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3923
3924         sdata->u.ap.multicast_to_unicast = enabled;
3925
3926         return 0;
3927 }
3928
3929 void ieee80211_fill_txq_stats(struct cfg80211_txq_stats *txqstats,
3930                               struct txq_info *txqi)
3931 {
3932         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_BACKLOG_BYTES))) {
3933                 txqstats->filled |= BIT(NL80211_TXQ_STATS_BACKLOG_BYTES);
3934                 txqstats->backlog_bytes = txqi->tin.backlog_bytes;
3935         }
3936
3937         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_BACKLOG_PACKETS))) {
3938                 txqstats->filled |= BIT(NL80211_TXQ_STATS_BACKLOG_PACKETS);
3939                 txqstats->backlog_packets = txqi->tin.backlog_packets;
3940         }
3941
3942         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_FLOWS))) {
3943                 txqstats->filled |= BIT(NL80211_TXQ_STATS_FLOWS);
3944                 txqstats->flows = txqi->tin.flows;
3945         }
3946
3947         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_DROPS))) {
3948                 txqstats->filled |= BIT(NL80211_TXQ_STATS_DROPS);
3949                 txqstats->drops = txqi->cstats.drop_count;
3950         }
3951
3952         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_ECN_MARKS))) {
3953                 txqstats->filled |= BIT(NL80211_TXQ_STATS_ECN_MARKS);
3954                 txqstats->ecn_marks = txqi->cstats.ecn_mark;
3955         }
3956
3957         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_OVERLIMIT))) {
3958                 txqstats->filled |= BIT(NL80211_TXQ_STATS_OVERLIMIT);
3959                 txqstats->overlimit = txqi->tin.overlimit;
3960         }
3961
3962         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_COLLISIONS))) {
3963                 txqstats->filled |= BIT(NL80211_TXQ_STATS_COLLISIONS);
3964                 txqstats->collisions = txqi->tin.collisions;
3965         }
3966
3967         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_TX_BYTES))) {
3968                 txqstats->filled |= BIT(NL80211_TXQ_STATS_TX_BYTES);
3969                 txqstats->tx_bytes = txqi->tin.tx_bytes;
3970         }
3971
3972         if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_TX_PACKETS))) {
3973                 txqstats->filled |= BIT(NL80211_TXQ_STATS_TX_PACKETS);
3974                 txqstats->tx_packets = txqi->tin.tx_packets;
3975         }
3976 }
3977
3978 static int ieee80211_get_txq_stats(struct wiphy *wiphy,
3979                                    struct wireless_dev *wdev,
3980                                    struct cfg80211_txq_stats *txqstats)
3981 {
3982         struct ieee80211_local *local = wiphy_priv(wiphy);
3983         struct ieee80211_sub_if_data *sdata;
3984         int ret = 0;
3985
3986         if (!local->ops->wake_tx_queue)
3987                 return 1;
3988
3989         spin_lock_bh(&local->fq.lock);
3990         rcu_read_lock();
3991
3992         if (wdev) {
3993                 sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3994                 if (!sdata->vif.txq) {
3995                         ret = 1;
3996                         goto out;
3997                 }
3998                 ieee80211_fill_txq_stats(txqstats, to_txq_info(sdata->vif.txq));
3999         } else {
4000                 /* phy stats */
4001                 txqstats->filled |= BIT(NL80211_TXQ_STATS_BACKLOG_PACKETS) |
4002                                     BIT(NL80211_TXQ_STATS_BACKLOG_BYTES) |
4003                                     BIT(NL80211_TXQ_STATS_OVERLIMIT) |
4004                                     BIT(NL80211_TXQ_STATS_OVERMEMORY) |
4005                                     BIT(NL80211_TXQ_STATS_COLLISIONS) |
4006                                     BIT(NL80211_TXQ_STATS_MAX_FLOWS);
4007                 txqstats->backlog_packets = local->fq.backlog;
4008                 txqstats->backlog_bytes = local->fq.memory_usage;
4009                 txqstats->overlimit = local->fq.overlimit;
4010                 txqstats->overmemory = local->fq.overmemory;
4011                 txqstats->collisions = local->fq.collisions;
4012                 txqstats->max_flows = local->fq.flows_cnt;
4013         }
4014
4015 out:
4016         rcu_read_unlock();
4017         spin_unlock_bh(&local->fq.lock);
4018
4019         return ret;
4020 }
4021
4022 static int
4023 ieee80211_get_ftm_responder_stats(struct wiphy *wiphy,
4024                                   struct net_device *dev,
4025                                   struct cfg80211_ftm_responder_stats *ftm_stats)
4026 {
4027         struct ieee80211_local *local = wiphy_priv(wiphy);
4028         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
4029
4030         return drv_get_ftm_responder_stats(local, sdata, ftm_stats);
4031 }
4032
4033 static int
4034 ieee80211_start_pmsr(struct wiphy *wiphy, struct wireless_dev *dev,
4035                      struct cfg80211_pmsr_request *request)
4036 {
4037         struct ieee80211_local *local = wiphy_priv(wiphy);
4038         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(dev);
4039
4040         return drv_start_pmsr(local, sdata, request);
4041 }
4042
4043 static void
4044 ieee80211_abort_pmsr(struct wiphy *wiphy, struct wireless_dev *dev,
4045                      struct cfg80211_pmsr_request *request)
4046 {
4047         struct ieee80211_local *local = wiphy_priv(wiphy);
4048         struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(dev);
4049
4050         return drv_abort_pmsr(local, sdata, request);
4051 }
4052
4053 static int ieee80211_set_tid_config(struct wiphy *wiphy,
4054                                     struct net_device *dev,
4055                                     struct cfg80211_tid_config *tid_conf)
4056 {
4057         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
4058         struct sta_info *sta;
4059         int ret;
4060
4061         if (!sdata->local->ops->set_tid_config)
4062                 return -EOPNOTSUPP;
4063
4064         if (!tid_conf->peer)
4065                 return drv_set_tid_config(sdata->local, sdata, NULL, tid_conf);
4066
4067         mutex_lock(&sdata->local->sta_mtx);
4068         sta = sta_info_get_bss(sdata, tid_conf->peer);
4069         if (!sta) {
4070                 mutex_unlock(&sdata->local->sta_mtx);
4071                 return -ENOENT;
4072         }
4073
4074         ret = drv_set_tid_config(sdata->local, sdata, &sta->sta, tid_conf);
4075         mutex_unlock(&sdata->local->sta_mtx);
4076
4077         return ret;
4078 }
4079
4080 static int ieee80211_reset_tid_config(struct wiphy *wiphy,
4081                                       struct net_device *dev,
4082                                       const u8 *peer, u8 tids)
4083 {
4084         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
4085         struct sta_info *sta;
4086         int ret;
4087
4088         if (!sdata->local->ops->reset_tid_config)
4089                 return -EOPNOTSUPP;
4090
4091         if (!peer)
4092                 return drv_reset_tid_config(sdata->local, sdata, NULL, tids);
4093
4094         mutex_lock(&sdata->local->sta_mtx);
4095         sta = sta_info_get_bss(sdata, peer);
4096         if (!sta) {
4097                 mutex_unlock(&sdata->local->sta_mtx);
4098                 return -ENOENT;
4099         }
4100
4101         ret = drv_reset_tid_config(sdata->local, sdata, &sta->sta, tids);
4102         mutex_unlock(&sdata->local->sta_mtx);
4103
4104         return ret;
4105 }
4106
4107 const struct cfg80211_ops mac80211_config_ops = {
4108         .add_virtual_intf = ieee80211_add_iface,
4109         .del_virtual_intf = ieee80211_del_iface,
4110         .change_virtual_intf = ieee80211_change_iface,
4111         .start_p2p_device = ieee80211_start_p2p_device,
4112         .stop_p2p_device = ieee80211_stop_p2p_device,
4113         .add_key = ieee80211_add_key,
4114         .del_key = ieee80211_del_key,
4115         .get_key = ieee80211_get_key,
4116         .set_default_key = ieee80211_config_default_key,
4117         .set_default_mgmt_key = ieee80211_config_default_mgmt_key,
4118         .set_default_beacon_key = ieee80211_config_default_beacon_key,
4119         .start_ap = ieee80211_start_ap,
4120         .change_beacon = ieee80211_change_beacon,
4121         .stop_ap = ieee80211_stop_ap,
4122         .add_station = ieee80211_add_station,
4123         .del_station = ieee80211_del_station,
4124         .change_station = ieee80211_change_station,
4125         .get_station = ieee80211_get_station,
4126         .dump_station = ieee80211_dump_station,
4127         .dump_survey = ieee80211_dump_survey,
4128 #ifdef CONFIG_MAC80211_MESH
4129         .add_mpath = ieee80211_add_mpath,
4130         .del_mpath = ieee80211_del_mpath,
4131         .change_mpath = ieee80211_change_mpath,
4132         .get_mpath = ieee80211_get_mpath,
4133         .dump_mpath = ieee80211_dump_mpath,
4134         .get_mpp = ieee80211_get_mpp,
4135         .dump_mpp = ieee80211_dump_mpp,
4136         .update_mesh_config = ieee80211_update_mesh_config,
4137         .get_mesh_config = ieee80211_get_mesh_config,
4138         .join_mesh = ieee80211_join_mesh,
4139         .leave_mesh = ieee80211_leave_mesh,
4140 #endif
4141         .join_ocb = ieee80211_join_ocb,
4142         .leave_ocb = ieee80211_leave_ocb,
4143         .change_bss = ieee80211_change_bss,
4144         .set_txq_params = ieee80211_set_txq_params,
4145         .set_monitor_channel = ieee80211_set_monitor_channel,
4146         .suspend = ieee80211_suspend,
4147         .resume = ieee80211_resume,
4148         .scan = ieee80211_scan,
4149         .abort_scan = ieee80211_abort_scan,
4150         .sched_scan_start = ieee80211_sched_scan_start,
4151         .sched_scan_stop = ieee80211_sched_scan_stop,
4152         .auth = ieee80211_auth,
4153         .assoc = ieee80211_assoc,
4154         .deauth = ieee80211_deauth,
4155         .disassoc = ieee80211_disassoc,
4156         .join_ibss = ieee80211_join_ibss,
4157         .leave_ibss = ieee80211_leave_ibss,
4158         .set_mcast_rate = ieee80211_set_mcast_rate,
4159         .set_wiphy_params = ieee80211_set_wiphy_params,
4160         .set_tx_power = ieee80211_set_tx_power,
4161         .get_tx_power = ieee80211_get_tx_power,
4162         .set_wds_peer = ieee80211_set_wds_peer,
4163         .rfkill_poll = ieee80211_rfkill_poll,
4164         CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
4165         CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
4166         .set_power_mgmt = ieee80211_set_power_mgmt,
4167         .set_bitrate_mask = ieee80211_set_bitrate_mask,
4168         .remain_on_channel = ieee80211_remain_on_channel,
4169         .cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
4170         .mgmt_tx = ieee80211_mgmt_tx,
4171         .mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
4172         .set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
4173         .set_cqm_rssi_range_config = ieee80211_set_cqm_rssi_range_config,
4174         .update_mgmt_frame_registrations =
4175                 ieee80211_update_mgmt_frame_registrations,
4176         .set_antenna = ieee80211_set_antenna,
4177         .get_antenna = ieee80211_get_antenna,
4178         .set_rekey_data = ieee80211_set_rekey_data,
4179         .tdls_oper = ieee80211_tdls_oper,
4180         .tdls_mgmt = ieee80211_tdls_mgmt,
4181         .tdls_channel_switch = ieee80211_tdls_channel_switch,
4182         .tdls_cancel_channel_switch = ieee80211_tdls_cancel_channel_switch,
4183         .probe_client = ieee80211_probe_client,
4184         .set_noack_map = ieee80211_set_noack_map,
4185 #ifdef CONFIG_PM
4186         .set_wakeup = ieee80211_set_wakeup,
4187 #endif
4188         .get_channel = ieee80211_cfg_get_channel,
4189         .start_radar_detection = ieee80211_start_radar_detection,
4190         .end_cac = ieee80211_end_cac,
4191         .channel_switch = ieee80211_channel_switch,
4192         .set_qos_map = ieee80211_set_qos_map,
4193         .set_ap_chanwidth = ieee80211_set_ap_chanwidth,
4194         .add_tx_ts = ieee80211_add_tx_ts,
4195         .del_tx_ts = ieee80211_del_tx_ts,
4196         .start_nan = ieee80211_start_nan,
4197         .stop_nan = ieee80211_stop_nan,
4198         .nan_change_conf = ieee80211_nan_change_conf,
4199         .add_nan_func = ieee80211_add_nan_func,
4200         .del_nan_func = ieee80211_del_nan_func,
4201         .set_multicast_to_unicast = ieee80211_set_multicast_to_unicast,
4202         .tx_control_port = ieee80211_tx_control_port,
4203         .get_txq_stats = ieee80211_get_txq_stats,
4204         .get_ftm_responder_stats = ieee80211_get_ftm_responder_stats,
4205         .start_pmsr = ieee80211_start_pmsr,
4206         .abort_pmsr = ieee80211_abort_pmsr,
4207         .probe_mesh_link = ieee80211_probe_mesh_link,
4208         .set_tid_config = ieee80211_set_tid_config,
4209         .reset_tid_config = ieee80211_reset_tid_config,
4210 };