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