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