1 /* 2 * Copyright (c) 2005-2011 Atheros Communications Inc. 3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 #include "mac.h" 19 20 #include <net/mac80211.h> 21 #include <linux/etherdevice.h> 22 23 #include "hif.h" 24 #include "core.h" 25 #include "debug.h" 26 #include "wmi.h" 27 #include "htt.h" 28 #include "txrx.h" 29 30 /**********/ 31 /* Crypto */ 32 /**********/ 33 34 static int ath10k_send_key(struct ath10k_vif *arvif, 35 struct ieee80211_key_conf *key, 36 enum set_key_cmd cmd, 37 const u8 *macaddr) 38 { 39 struct wmi_vdev_install_key_arg arg = { 40 .vdev_id = arvif->vdev_id, 41 .key_idx = key->keyidx, 42 .key_len = key->keylen, 43 .key_data = key->key, 44 .macaddr = macaddr, 45 }; 46 47 lockdep_assert_held(&arvif->ar->conf_mutex); 48 49 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 50 arg.key_flags = WMI_KEY_PAIRWISE; 51 else 52 arg.key_flags = WMI_KEY_GROUP; 53 54 switch (key->cipher) { 55 case WLAN_CIPHER_SUITE_CCMP: 56 arg.key_cipher = WMI_CIPHER_AES_CCM; 57 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX; 58 break; 59 case WLAN_CIPHER_SUITE_TKIP: 60 arg.key_cipher = WMI_CIPHER_TKIP; 61 arg.key_txmic_len = 8; 62 arg.key_rxmic_len = 8; 63 break; 64 case WLAN_CIPHER_SUITE_WEP40: 65 case WLAN_CIPHER_SUITE_WEP104: 66 arg.key_cipher = WMI_CIPHER_WEP; 67 /* AP/IBSS mode requires self-key to be groupwise 68 * Otherwise pairwise key must be set */ 69 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN)) 70 arg.key_flags = WMI_KEY_PAIRWISE; 71 break; 72 default: 73 ath10k_warn("cipher %d is not supported\n", key->cipher); 74 return -EOPNOTSUPP; 75 } 76 77 if (cmd == DISABLE_KEY) { 78 arg.key_cipher = WMI_CIPHER_NONE; 79 arg.key_data = NULL; 80 } 81 82 return ath10k_wmi_vdev_install_key(arvif->ar, &arg); 83 } 84 85 static int ath10k_install_key(struct ath10k_vif *arvif, 86 struct ieee80211_key_conf *key, 87 enum set_key_cmd cmd, 88 const u8 *macaddr) 89 { 90 struct ath10k *ar = arvif->ar; 91 int ret; 92 93 lockdep_assert_held(&ar->conf_mutex); 94 95 reinit_completion(&ar->install_key_done); 96 97 ret = ath10k_send_key(arvif, key, cmd, macaddr); 98 if (ret) 99 return ret; 100 101 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ); 102 if (ret == 0) 103 return -ETIMEDOUT; 104 105 return 0; 106 } 107 108 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif, 109 const u8 *addr) 110 { 111 struct ath10k *ar = arvif->ar; 112 struct ath10k_peer *peer; 113 int ret; 114 int i; 115 116 lockdep_assert_held(&ar->conf_mutex); 117 118 spin_lock_bh(&ar->data_lock); 119 peer = ath10k_peer_find(ar, arvif->vdev_id, addr); 120 spin_unlock_bh(&ar->data_lock); 121 122 if (!peer) 123 return -ENOENT; 124 125 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) { 126 if (arvif->wep_keys[i] == NULL) 127 continue; 128 129 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY, 130 addr); 131 if (ret) 132 return ret; 133 134 peer->keys[i] = arvif->wep_keys[i]; 135 } 136 137 return 0; 138 } 139 140 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif, 141 const u8 *addr) 142 { 143 struct ath10k *ar = arvif->ar; 144 struct ath10k_peer *peer; 145 int first_errno = 0; 146 int ret; 147 int i; 148 149 lockdep_assert_held(&ar->conf_mutex); 150 151 spin_lock_bh(&ar->data_lock); 152 peer = ath10k_peer_find(ar, arvif->vdev_id, addr); 153 spin_unlock_bh(&ar->data_lock); 154 155 if (!peer) 156 return -ENOENT; 157 158 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 159 if (peer->keys[i] == NULL) 160 continue; 161 162 ret = ath10k_install_key(arvif, peer->keys[i], 163 DISABLE_KEY, addr); 164 if (ret && first_errno == 0) 165 first_errno = ret; 166 167 if (ret) 168 ath10k_warn("could not remove peer wep key %d (%d)\n", 169 i, ret); 170 171 peer->keys[i] = NULL; 172 } 173 174 return first_errno; 175 } 176 177 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif, 178 struct ieee80211_key_conf *key) 179 { 180 struct ath10k *ar = arvif->ar; 181 struct ath10k_peer *peer; 182 u8 addr[ETH_ALEN]; 183 int first_errno = 0; 184 int ret; 185 int i; 186 187 lockdep_assert_held(&ar->conf_mutex); 188 189 for (;;) { 190 /* since ath10k_install_key we can't hold data_lock all the 191 * time, so we try to remove the keys incrementally */ 192 spin_lock_bh(&ar->data_lock); 193 i = 0; 194 list_for_each_entry(peer, &ar->peers, list) { 195 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) { 196 if (peer->keys[i] == key) { 197 memcpy(addr, peer->addr, ETH_ALEN); 198 peer->keys[i] = NULL; 199 break; 200 } 201 } 202 203 if (i < ARRAY_SIZE(peer->keys)) 204 break; 205 } 206 spin_unlock_bh(&ar->data_lock); 207 208 if (i == ARRAY_SIZE(peer->keys)) 209 break; 210 211 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr); 212 if (ret && first_errno == 0) 213 first_errno = ret; 214 215 if (ret) 216 ath10k_warn("could not remove key for %pM\n", addr); 217 } 218 219 return first_errno; 220 } 221 222 223 /*********************/ 224 /* General utilities */ 225 /*********************/ 226 227 static inline enum wmi_phy_mode 228 chan_to_phymode(const struct cfg80211_chan_def *chandef) 229 { 230 enum wmi_phy_mode phymode = MODE_UNKNOWN; 231 232 switch (chandef->chan->band) { 233 case IEEE80211_BAND_2GHZ: 234 switch (chandef->width) { 235 case NL80211_CHAN_WIDTH_20_NOHT: 236 phymode = MODE_11G; 237 break; 238 case NL80211_CHAN_WIDTH_20: 239 phymode = MODE_11NG_HT20; 240 break; 241 case NL80211_CHAN_WIDTH_40: 242 phymode = MODE_11NG_HT40; 243 break; 244 case NL80211_CHAN_WIDTH_5: 245 case NL80211_CHAN_WIDTH_10: 246 case NL80211_CHAN_WIDTH_80: 247 case NL80211_CHAN_WIDTH_80P80: 248 case NL80211_CHAN_WIDTH_160: 249 phymode = MODE_UNKNOWN; 250 break; 251 } 252 break; 253 case IEEE80211_BAND_5GHZ: 254 switch (chandef->width) { 255 case NL80211_CHAN_WIDTH_20_NOHT: 256 phymode = MODE_11A; 257 break; 258 case NL80211_CHAN_WIDTH_20: 259 phymode = MODE_11NA_HT20; 260 break; 261 case NL80211_CHAN_WIDTH_40: 262 phymode = MODE_11NA_HT40; 263 break; 264 case NL80211_CHAN_WIDTH_80: 265 phymode = MODE_11AC_VHT80; 266 break; 267 case NL80211_CHAN_WIDTH_5: 268 case NL80211_CHAN_WIDTH_10: 269 case NL80211_CHAN_WIDTH_80P80: 270 case NL80211_CHAN_WIDTH_160: 271 phymode = MODE_UNKNOWN; 272 break; 273 } 274 break; 275 default: 276 break; 277 } 278 279 WARN_ON(phymode == MODE_UNKNOWN); 280 return phymode; 281 } 282 283 static u8 ath10k_parse_mpdudensity(u8 mpdudensity) 284 { 285 /* 286 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing": 287 * 0 for no restriction 288 * 1 for 1/4 us 289 * 2 for 1/2 us 290 * 3 for 1 us 291 * 4 for 2 us 292 * 5 for 4 us 293 * 6 for 8 us 294 * 7 for 16 us 295 */ 296 switch (mpdudensity) { 297 case 0: 298 return 0; 299 case 1: 300 case 2: 301 case 3: 302 /* Our lower layer calculations limit our precision to 303 1 microsecond */ 304 return 1; 305 case 4: 306 return 2; 307 case 5: 308 return 4; 309 case 6: 310 return 8; 311 case 7: 312 return 16; 313 default: 314 return 0; 315 } 316 } 317 318 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr) 319 { 320 int ret; 321 322 lockdep_assert_held(&ar->conf_mutex); 323 324 ret = ath10k_wmi_peer_create(ar, vdev_id, addr); 325 if (ret) { 326 ath10k_warn("Failed to create wmi peer %pM on vdev %i: %i\n", 327 addr, vdev_id, ret); 328 return ret; 329 } 330 331 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr); 332 if (ret) { 333 ath10k_warn("Failed to wait for created wmi peer %pM on vdev %i: %i\n", 334 addr, vdev_id, ret); 335 return ret; 336 } 337 spin_lock_bh(&ar->data_lock); 338 ar->num_peers++; 339 spin_unlock_bh(&ar->data_lock); 340 341 return 0; 342 } 343 344 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif) 345 { 346 struct ath10k *ar = arvif->ar; 347 u32 param; 348 int ret; 349 350 param = ar->wmi.pdev_param->sta_kickout_th; 351 ret = ath10k_wmi_pdev_set_param(ar, param, 352 ATH10K_KICKOUT_THRESHOLD); 353 if (ret) { 354 ath10k_warn("Failed to set kickout threshold on vdev %i: %d\n", 355 arvif->vdev_id, ret); 356 return ret; 357 } 358 359 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs; 360 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 361 ATH10K_KEEPALIVE_MIN_IDLE); 362 if (ret) { 363 ath10k_warn("Failed to set keepalive minimum idle time on vdev %i : %d\n", 364 arvif->vdev_id, ret); 365 return ret; 366 } 367 368 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs; 369 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 370 ATH10K_KEEPALIVE_MAX_IDLE); 371 if (ret) { 372 ath10k_warn("Failed to set keepalive maximum idle time on vdev %i: %d\n", 373 arvif->vdev_id, ret); 374 return ret; 375 } 376 377 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs; 378 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, 379 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE); 380 if (ret) { 381 ath10k_warn("Failed to set keepalive maximum unresponsive time on vdev %i: %d\n", 382 arvif->vdev_id, ret); 383 return ret; 384 } 385 386 return 0; 387 } 388 389 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value) 390 { 391 struct ath10k *ar = arvif->ar; 392 u32 vdev_param; 393 394 if (value != 0xFFFFFFFF) 395 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold, 396 ATH10K_RTS_MAX); 397 398 vdev_param = ar->wmi.vdev_param->rts_threshold; 399 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value); 400 } 401 402 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value) 403 { 404 struct ath10k *ar = arvif->ar; 405 u32 vdev_param; 406 407 if (value != 0xFFFFFFFF) 408 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold, 409 ATH10K_FRAGMT_THRESHOLD_MIN, 410 ATH10K_FRAGMT_THRESHOLD_MAX); 411 412 vdev_param = ar->wmi.vdev_param->fragmentation_threshold; 413 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value); 414 } 415 416 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr) 417 { 418 int ret; 419 420 lockdep_assert_held(&ar->conf_mutex); 421 422 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr); 423 if (ret) 424 return ret; 425 426 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr); 427 if (ret) 428 return ret; 429 430 spin_lock_bh(&ar->data_lock); 431 ar->num_peers--; 432 spin_unlock_bh(&ar->data_lock); 433 434 return 0; 435 } 436 437 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id) 438 { 439 struct ath10k_peer *peer, *tmp; 440 441 lockdep_assert_held(&ar->conf_mutex); 442 443 spin_lock_bh(&ar->data_lock); 444 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 445 if (peer->vdev_id != vdev_id) 446 continue; 447 448 ath10k_warn("removing stale peer %pM from vdev_id %d\n", 449 peer->addr, vdev_id); 450 451 list_del(&peer->list); 452 kfree(peer); 453 ar->num_peers--; 454 } 455 spin_unlock_bh(&ar->data_lock); 456 } 457 458 static void ath10k_peer_cleanup_all(struct ath10k *ar) 459 { 460 struct ath10k_peer *peer, *tmp; 461 462 lockdep_assert_held(&ar->conf_mutex); 463 464 spin_lock_bh(&ar->data_lock); 465 list_for_each_entry_safe(peer, tmp, &ar->peers, list) { 466 list_del(&peer->list); 467 kfree(peer); 468 } 469 ar->num_peers = 0; 470 spin_unlock_bh(&ar->data_lock); 471 } 472 473 /************************/ 474 /* Interface management */ 475 /************************/ 476 477 static inline int ath10k_vdev_setup_sync(struct ath10k *ar) 478 { 479 int ret; 480 481 lockdep_assert_held(&ar->conf_mutex); 482 483 ret = wait_for_completion_timeout(&ar->vdev_setup_done, 484 ATH10K_VDEV_SETUP_TIMEOUT_HZ); 485 if (ret == 0) 486 return -ETIMEDOUT; 487 488 return 0; 489 } 490 491 static int ath10k_vdev_start(struct ath10k_vif *arvif) 492 { 493 struct ath10k *ar = arvif->ar; 494 struct cfg80211_chan_def *chandef = &ar->chandef; 495 struct wmi_vdev_start_request_arg arg = {}; 496 int ret = 0; 497 498 lockdep_assert_held(&ar->conf_mutex); 499 500 reinit_completion(&ar->vdev_setup_done); 501 502 arg.vdev_id = arvif->vdev_id; 503 arg.dtim_period = arvif->dtim_period; 504 arg.bcn_intval = arvif->beacon_interval; 505 506 arg.channel.freq = chandef->chan->center_freq; 507 arg.channel.band_center_freq1 = chandef->center_freq1; 508 arg.channel.mode = chan_to_phymode(chandef); 509 510 arg.channel.min_power = 0; 511 arg.channel.max_power = chandef->chan->max_power * 2; 512 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2; 513 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2; 514 515 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 516 arg.ssid = arvif->u.ap.ssid; 517 arg.ssid_len = arvif->u.ap.ssid_len; 518 arg.hidden_ssid = arvif->u.ap.hidden_ssid; 519 520 /* For now allow DFS for AP mode */ 521 arg.channel.chan_radar = 522 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR); 523 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) { 524 arg.ssid = arvif->vif->bss_conf.ssid; 525 arg.ssid_len = arvif->vif->bss_conf.ssid_len; 526 } 527 528 ath10k_dbg(ATH10K_DBG_MAC, 529 "mac vdev %d start center_freq %d phymode %s\n", 530 arg.vdev_id, arg.channel.freq, 531 ath10k_wmi_phymode_str(arg.channel.mode)); 532 533 ret = ath10k_wmi_vdev_start(ar, &arg); 534 if (ret) { 535 ath10k_warn("WMI vdev %i start failed: ret %d\n", 536 arg.vdev_id, ret); 537 return ret; 538 } 539 540 ret = ath10k_vdev_setup_sync(ar); 541 if (ret) { 542 ath10k_warn("vdev %i setup failed %d\n", 543 arg.vdev_id, ret); 544 return ret; 545 } 546 547 return ret; 548 } 549 550 static int ath10k_vdev_stop(struct ath10k_vif *arvif) 551 { 552 struct ath10k *ar = arvif->ar; 553 int ret; 554 555 lockdep_assert_held(&ar->conf_mutex); 556 557 reinit_completion(&ar->vdev_setup_done); 558 559 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id); 560 if (ret) { 561 ath10k_warn("WMI vdev %i stop failed: ret %d\n", 562 arvif->vdev_id, ret); 563 return ret; 564 } 565 566 ret = ath10k_vdev_setup_sync(ar); 567 if (ret) { 568 ath10k_warn("vdev %i setup sync failed %d\n", 569 arvif->vdev_id, ret); 570 return ret; 571 } 572 573 return ret; 574 } 575 576 static int ath10k_monitor_start(struct ath10k *ar, int vdev_id) 577 { 578 struct cfg80211_chan_def *chandef = &ar->chandef; 579 struct ieee80211_channel *channel = chandef->chan; 580 struct wmi_vdev_start_request_arg arg = {}; 581 int ret = 0; 582 583 lockdep_assert_held(&ar->conf_mutex); 584 585 if (!ar->monitor_present) { 586 ath10k_warn("mac montor stop -- monitor is not present\n"); 587 return -EINVAL; 588 } 589 590 arg.vdev_id = vdev_id; 591 arg.channel.freq = channel->center_freq; 592 arg.channel.band_center_freq1 = chandef->center_freq1; 593 594 /* TODO setup this dynamically, what in case we 595 don't have any vifs? */ 596 arg.channel.mode = chan_to_phymode(chandef); 597 arg.channel.chan_radar = 598 !!(channel->flags & IEEE80211_CHAN_RADAR); 599 600 arg.channel.min_power = 0; 601 arg.channel.max_power = channel->max_power * 2; 602 arg.channel.max_reg_power = channel->max_reg_power * 2; 603 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2; 604 605 ret = ath10k_wmi_vdev_start(ar, &arg); 606 if (ret) { 607 ath10k_warn("Monitor vdev %i start failed: ret %d\n", 608 vdev_id, ret); 609 return ret; 610 } 611 612 ret = ath10k_vdev_setup_sync(ar); 613 if (ret) { 614 ath10k_warn("Monitor vdev %i setup failed %d\n", 615 vdev_id, ret); 616 return ret; 617 } 618 619 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr); 620 if (ret) { 621 ath10k_warn("Monitor vdev %i up failed: %d\n", 622 vdev_id, ret); 623 goto vdev_stop; 624 } 625 626 ar->monitor_vdev_id = vdev_id; 627 ar->monitor_enabled = true; 628 629 return 0; 630 631 vdev_stop: 632 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 633 if (ret) 634 ath10k_warn("Monitor vdev %i stop failed: %d\n", 635 ar->monitor_vdev_id, ret); 636 637 return ret; 638 } 639 640 static int ath10k_monitor_stop(struct ath10k *ar) 641 { 642 int ret = 0; 643 644 lockdep_assert_held(&ar->conf_mutex); 645 646 if (!ar->monitor_present) { 647 ath10k_warn("mac montor stop -- monitor is not present\n"); 648 return -EINVAL; 649 } 650 651 if (!ar->monitor_enabled) { 652 ath10k_warn("mac montor stop -- monitor is not enabled\n"); 653 return -EINVAL; 654 } 655 656 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id); 657 if (ret) 658 ath10k_warn("Monitor vdev %i down failed: %d\n", 659 ar->monitor_vdev_id, ret); 660 661 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id); 662 if (ret) 663 ath10k_warn("Monitor vdev %i stop failed: %d\n", 664 ar->monitor_vdev_id, ret); 665 666 ret = ath10k_vdev_setup_sync(ar); 667 if (ret) 668 ath10k_warn("Monitor_down sync failed, vdev %i: %d\n", 669 ar->monitor_vdev_id, ret); 670 671 ar->monitor_enabled = false; 672 return ret; 673 } 674 675 static int ath10k_monitor_create(struct ath10k *ar) 676 { 677 int bit, ret = 0; 678 679 lockdep_assert_held(&ar->conf_mutex); 680 681 if (ar->monitor_present) { 682 ath10k_warn("Monitor mode already enabled\n"); 683 return 0; 684 } 685 686 bit = ffs(ar->free_vdev_map); 687 if (bit == 0) { 688 ath10k_warn("No free VDEV slots\n"); 689 return -ENOMEM; 690 } 691 692 ar->monitor_vdev_id = bit - 1; 693 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id); 694 695 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id, 696 WMI_VDEV_TYPE_MONITOR, 697 0, ar->mac_addr); 698 if (ret) { 699 ath10k_warn("WMI vdev %i monitor create failed: ret %d\n", 700 ar->monitor_vdev_id, ret); 701 goto vdev_fail; 702 } 703 704 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d created\n", 705 ar->monitor_vdev_id); 706 707 ar->monitor_present = true; 708 return 0; 709 710 vdev_fail: 711 /* 712 * Restore the ID to the global map. 713 */ 714 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id); 715 return ret; 716 } 717 718 static int ath10k_monitor_destroy(struct ath10k *ar) 719 { 720 int ret = 0; 721 722 lockdep_assert_held(&ar->conf_mutex); 723 724 if (!ar->monitor_present) 725 return 0; 726 727 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id); 728 if (ret) { 729 ath10k_warn("WMI vdev %i monitor delete failed: %d\n", 730 ar->monitor_vdev_id, ret); 731 return ret; 732 } 733 734 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id); 735 ar->monitor_present = false; 736 737 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n", 738 ar->monitor_vdev_id); 739 return ret; 740 } 741 742 static int ath10k_start_cac(struct ath10k *ar) 743 { 744 int ret; 745 746 lockdep_assert_held(&ar->conf_mutex); 747 748 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 749 750 ret = ath10k_monitor_create(ar); 751 if (ret) { 752 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 753 return ret; 754 } 755 756 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id); 757 if (ret) { 758 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 759 ath10k_monitor_destroy(ar); 760 return ret; 761 } 762 763 ath10k_dbg(ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n", 764 ar->monitor_vdev_id); 765 766 return 0; 767 } 768 769 static int ath10k_stop_cac(struct ath10k *ar) 770 { 771 lockdep_assert_held(&ar->conf_mutex); 772 773 /* CAC is not running - do nothing */ 774 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags)) 775 return 0; 776 777 ath10k_monitor_stop(ar); 778 ath10k_monitor_destroy(ar); 779 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags); 780 781 ath10k_dbg(ATH10K_DBG_MAC, "mac cac finished\n"); 782 783 return 0; 784 } 785 786 static const char *ath10k_dfs_state(enum nl80211_dfs_state dfs_state) 787 { 788 switch (dfs_state) { 789 case NL80211_DFS_USABLE: 790 return "USABLE"; 791 case NL80211_DFS_UNAVAILABLE: 792 return "UNAVAILABLE"; 793 case NL80211_DFS_AVAILABLE: 794 return "AVAILABLE"; 795 default: 796 WARN_ON(1); 797 return "bug"; 798 } 799 } 800 801 static void ath10k_config_radar_detection(struct ath10k *ar) 802 { 803 struct ieee80211_channel *chan = ar->hw->conf.chandef.chan; 804 bool radar = ar->hw->conf.radar_enabled; 805 bool chan_radar = !!(chan->flags & IEEE80211_CHAN_RADAR); 806 enum nl80211_dfs_state dfs_state = chan->dfs_state; 807 int ret; 808 809 lockdep_assert_held(&ar->conf_mutex); 810 811 ath10k_dbg(ATH10K_DBG_MAC, 812 "mac radar config update: chan %dMHz radar %d chan radar %d chan state %s\n", 813 chan->center_freq, radar, chan_radar, 814 ath10k_dfs_state(dfs_state)); 815 816 /* 817 * It's safe to call it even if CAC is not started. 818 * This call here guarantees changing channel, etc. will stop CAC. 819 */ 820 ath10k_stop_cac(ar); 821 822 if (!radar) 823 return; 824 825 if (!chan_radar) 826 return; 827 828 if (dfs_state != NL80211_DFS_USABLE) 829 return; 830 831 ret = ath10k_start_cac(ar); 832 if (ret) { 833 /* 834 * Not possible to start CAC on current channel so starting 835 * radiation is not allowed, make this channel DFS_UNAVAILABLE 836 * by indicating that radar was detected. 837 */ 838 ath10k_warn("failed to start CAC (%d)\n", ret); 839 ieee80211_radar_detected(ar->hw); 840 } 841 } 842 843 static void ath10k_control_beaconing(struct ath10k_vif *arvif, 844 struct ieee80211_bss_conf *info) 845 { 846 int ret = 0; 847 848 lockdep_assert_held(&arvif->ar->conf_mutex); 849 850 if (!info->enable_beacon) { 851 ath10k_vdev_stop(arvif); 852 853 arvif->is_started = false; 854 arvif->is_up = false; 855 856 spin_lock_bh(&arvif->ar->data_lock); 857 if (arvif->beacon) { 858 dma_unmap_single(arvif->ar->dev, 859 ATH10K_SKB_CB(arvif->beacon)->paddr, 860 arvif->beacon->len, DMA_TO_DEVICE); 861 dev_kfree_skb_any(arvif->beacon); 862 863 arvif->beacon = NULL; 864 arvif->beacon_sent = false; 865 } 866 spin_unlock_bh(&arvif->ar->data_lock); 867 868 return; 869 } 870 871 arvif->tx_seq_no = 0x1000; 872 873 ret = ath10k_vdev_start(arvif); 874 if (ret) 875 return; 876 877 arvif->aid = 0; 878 memcpy(arvif->bssid, info->bssid, ETH_ALEN); 879 880 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 881 arvif->bssid); 882 if (ret) { 883 ath10k_warn("Failed to bring up vdev %d: %i\n", 884 arvif->vdev_id, ret); 885 ath10k_vdev_stop(arvif); 886 return; 887 } 888 889 arvif->is_started = true; 890 arvif->is_up = true; 891 892 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id); 893 } 894 895 static void ath10k_control_ibss(struct ath10k_vif *arvif, 896 struct ieee80211_bss_conf *info, 897 const u8 self_peer[ETH_ALEN]) 898 { 899 u32 vdev_param; 900 int ret = 0; 901 902 lockdep_assert_held(&arvif->ar->conf_mutex); 903 904 if (!info->ibss_joined) { 905 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer); 906 if (ret) 907 ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n", 908 self_peer, arvif->vdev_id, ret); 909 910 if (is_zero_ether_addr(arvif->bssid)) 911 return; 912 913 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, 914 arvif->bssid); 915 if (ret) { 916 ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n", 917 arvif->bssid, arvif->vdev_id, ret); 918 return; 919 } 920 921 memset(arvif->bssid, 0, ETH_ALEN); 922 923 return; 924 } 925 926 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer); 927 if (ret) { 928 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n", 929 self_peer, arvif->vdev_id, ret); 930 return; 931 } 932 933 vdev_param = arvif->ar->wmi.vdev_param->atim_window; 934 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param, 935 ATH10K_DEFAULT_ATIM); 936 if (ret) 937 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n", 938 arvif->vdev_id, ret); 939 } 940 941 /* 942 * Review this when mac80211 gains per-interface powersave support. 943 */ 944 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif) 945 { 946 struct ath10k *ar = arvif->ar; 947 struct ieee80211_conf *conf = &ar->hw->conf; 948 enum wmi_sta_powersave_param param; 949 enum wmi_sta_ps_mode psmode; 950 int ret; 951 952 lockdep_assert_held(&arvif->ar->conf_mutex); 953 954 if (arvif->vif->type != NL80211_IFTYPE_STATION) 955 return 0; 956 957 if (conf->flags & IEEE80211_CONF_PS) { 958 psmode = WMI_STA_PS_MODE_ENABLED; 959 param = WMI_STA_PS_PARAM_INACTIVITY_TIME; 960 961 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, 962 conf->dynamic_ps_timeout); 963 if (ret) { 964 ath10k_warn("Failed to set inactivity time for vdev %d: %i\n", 965 arvif->vdev_id, ret); 966 return ret; 967 } 968 } else { 969 psmode = WMI_STA_PS_MODE_DISABLED; 970 } 971 972 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d psmode %s\n", 973 arvif->vdev_id, psmode ? "enable" : "disable"); 974 975 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode); 976 if (ret) { 977 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n", 978 psmode, arvif->vdev_id); 979 return ret; 980 } 981 982 return 0; 983 } 984 985 /**********************/ 986 /* Station management */ 987 /**********************/ 988 989 static void ath10k_peer_assoc_h_basic(struct ath10k *ar, 990 struct ath10k_vif *arvif, 991 struct ieee80211_sta *sta, 992 struct ieee80211_bss_conf *bss_conf, 993 struct wmi_peer_assoc_complete_arg *arg) 994 { 995 lockdep_assert_held(&ar->conf_mutex); 996 997 memcpy(arg->addr, sta->addr, ETH_ALEN); 998 arg->vdev_id = arvif->vdev_id; 999 arg->peer_aid = sta->aid; 1000 arg->peer_flags |= WMI_PEER_AUTH; 1001 1002 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 1003 /* 1004 * Seems FW have problems with Power Save in STA 1005 * mode when we setup this parameter to high (eg. 5). 1006 * Often we see that FW don't send NULL (with clean P flags) 1007 * frame even there is info about buffered frames in beacons. 1008 * Sometimes we have to wait more than 10 seconds before FW 1009 * will wakeup. Often sending one ping from AP to our device 1010 * just fail (more than 50%). 1011 * 1012 * Seems setting this FW parameter to 1 couse FW 1013 * will check every beacon and will wakup immediately 1014 * after detection buffered data. 1015 */ 1016 arg->peer_listen_intval = 1; 1017 else 1018 arg->peer_listen_intval = ar->hw->conf.listen_interval; 1019 1020 arg->peer_num_spatial_streams = 1; 1021 1022 /* 1023 * The assoc capabilities are available only in managed mode. 1024 */ 1025 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf) 1026 arg->peer_caps = bss_conf->assoc_capability; 1027 } 1028 1029 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar, 1030 struct ath10k_vif *arvif, 1031 struct wmi_peer_assoc_complete_arg *arg) 1032 { 1033 struct ieee80211_vif *vif = arvif->vif; 1034 struct ieee80211_bss_conf *info = &vif->bss_conf; 1035 struct cfg80211_bss *bss; 1036 const u8 *rsnie = NULL; 1037 const u8 *wpaie = NULL; 1038 1039 lockdep_assert_held(&ar->conf_mutex); 1040 1041 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan, 1042 info->bssid, NULL, 0, 0, 0); 1043 if (bss) { 1044 const struct cfg80211_bss_ies *ies; 1045 1046 rcu_read_lock(); 1047 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN); 1048 1049 ies = rcu_dereference(bss->ies); 1050 1051 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, 1052 WLAN_OUI_TYPE_MICROSOFT_WPA, 1053 ies->data, 1054 ies->len); 1055 rcu_read_unlock(); 1056 cfg80211_put_bss(ar->hw->wiphy, bss); 1057 } 1058 1059 /* FIXME: base on RSN IE/WPA IE is a correct idea? */ 1060 if (rsnie || wpaie) { 1061 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__); 1062 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY; 1063 } 1064 1065 if (wpaie) { 1066 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__); 1067 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY; 1068 } 1069 } 1070 1071 static void ath10k_peer_assoc_h_rates(struct ath10k *ar, 1072 struct ieee80211_sta *sta, 1073 struct wmi_peer_assoc_complete_arg *arg) 1074 { 1075 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates; 1076 const struct ieee80211_supported_band *sband; 1077 const struct ieee80211_rate *rates; 1078 u32 ratemask; 1079 int i; 1080 1081 lockdep_assert_held(&ar->conf_mutex); 1082 1083 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band]; 1084 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band]; 1085 rates = sband->bitrates; 1086 1087 rateset->num_rates = 0; 1088 1089 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) { 1090 if (!(ratemask & 1)) 1091 continue; 1092 1093 rateset->rates[rateset->num_rates] = rates->hw_value; 1094 rateset->num_rates++; 1095 } 1096 } 1097 1098 static void ath10k_peer_assoc_h_ht(struct ath10k *ar, 1099 struct ieee80211_sta *sta, 1100 struct wmi_peer_assoc_complete_arg *arg) 1101 { 1102 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap; 1103 int i, n; 1104 1105 lockdep_assert_held(&ar->conf_mutex); 1106 1107 if (!ht_cap->ht_supported) 1108 return; 1109 1110 arg->peer_flags |= WMI_PEER_HT; 1111 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + 1112 ht_cap->ampdu_factor)) - 1; 1113 1114 arg->peer_mpdu_density = 1115 ath10k_parse_mpdudensity(ht_cap->ampdu_density); 1116 1117 arg->peer_ht_caps = ht_cap->cap; 1118 arg->peer_rate_caps |= WMI_RC_HT_FLAG; 1119 1120 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING) 1121 arg->peer_flags |= WMI_PEER_LDPC; 1122 1123 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) { 1124 arg->peer_flags |= WMI_PEER_40MHZ; 1125 arg->peer_rate_caps |= WMI_RC_CW40_FLAG; 1126 } 1127 1128 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20) 1129 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 1130 1131 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40) 1132 arg->peer_rate_caps |= WMI_RC_SGI_FLAG; 1133 1134 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) { 1135 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG; 1136 arg->peer_flags |= WMI_PEER_STBC; 1137 } 1138 1139 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) { 1140 u32 stbc; 1141 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC; 1142 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT; 1143 stbc = stbc << WMI_RC_RX_STBC_FLAG_S; 1144 arg->peer_rate_caps |= stbc; 1145 arg->peer_flags |= WMI_PEER_STBC; 1146 } 1147 1148 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2]) 1149 arg->peer_rate_caps |= WMI_RC_TS_FLAG; 1150 else if (ht_cap->mcs.rx_mask[1]) 1151 arg->peer_rate_caps |= WMI_RC_DS_FLAG; 1152 1153 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++) 1154 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8)) 1155 arg->peer_ht_rates.rates[n++] = i; 1156 1157 /* 1158 * This is a workaround for HT-enabled STAs which break the spec 1159 * and have no HT capabilities RX mask (no HT RX MCS map). 1160 * 1161 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS), 1162 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs. 1163 * 1164 * Firmware asserts if such situation occurs. 1165 */ 1166 if (n == 0) { 1167 arg->peer_ht_rates.num_rates = 8; 1168 for (i = 0; i < arg->peer_ht_rates.num_rates; i++) 1169 arg->peer_ht_rates.rates[i] = i; 1170 } else { 1171 arg->peer_ht_rates.num_rates = n; 1172 arg->peer_num_spatial_streams = sta->rx_nss; 1173 } 1174 1175 ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n", 1176 arg->addr, 1177 arg->peer_ht_rates.num_rates, 1178 arg->peer_num_spatial_streams); 1179 } 1180 1181 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar, 1182 struct ath10k_vif *arvif, 1183 struct ieee80211_sta *sta) 1184 { 1185 u32 uapsd = 0; 1186 u32 max_sp = 0; 1187 int ret = 0; 1188 1189 lockdep_assert_held(&ar->conf_mutex); 1190 1191 if (sta->wme && sta->uapsd_queues) { 1192 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n", 1193 sta->uapsd_queues, sta->max_sp); 1194 1195 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) 1196 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | 1197 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN; 1198 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) 1199 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | 1200 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN; 1201 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) 1202 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | 1203 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN; 1204 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) 1205 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | 1206 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN; 1207 1208 1209 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP) 1210 max_sp = sta->max_sp; 1211 1212 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 1213 sta->addr, 1214 WMI_AP_PS_PEER_PARAM_UAPSD, 1215 uapsd); 1216 if (ret) { 1217 ath10k_warn("failed to set ap ps peer param uapsd for vdev %i: %d\n", 1218 arvif->vdev_id, ret); 1219 return ret; 1220 } 1221 1222 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, 1223 sta->addr, 1224 WMI_AP_PS_PEER_PARAM_MAX_SP, 1225 max_sp); 1226 if (ret) { 1227 ath10k_warn("failed to set ap ps peer param max sp for vdev %i: %d\n", 1228 arvif->vdev_id, ret); 1229 return ret; 1230 } 1231 1232 /* TODO setup this based on STA listen interval and 1233 beacon interval. Currently we don't know 1234 sta->listen_interval - mac80211 patch required. 1235 Currently use 10 seconds */ 1236 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr, 1237 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 10); 1238 if (ret) { 1239 ath10k_warn("failed to set ap ps peer param ageout time for vdev %i: %d\n", 1240 arvif->vdev_id, ret); 1241 return ret; 1242 } 1243 } 1244 1245 return 0; 1246 } 1247 1248 static void ath10k_peer_assoc_h_vht(struct ath10k *ar, 1249 struct ieee80211_sta *sta, 1250 struct wmi_peer_assoc_complete_arg *arg) 1251 { 1252 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap; 1253 u8 ampdu_factor; 1254 1255 if (!vht_cap->vht_supported) 1256 return; 1257 1258 arg->peer_flags |= WMI_PEER_VHT; 1259 arg->peer_vht_caps = vht_cap->cap; 1260 1261 1262 ampdu_factor = (vht_cap->cap & 1263 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >> 1264 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT; 1265 1266 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to 1267 * zero in VHT IE. Using it would result in degraded throughput. 1268 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep 1269 * it if VHT max_mpdu is smaller. */ 1270 arg->peer_max_mpdu = max(arg->peer_max_mpdu, 1271 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR + 1272 ampdu_factor)) - 1); 1273 1274 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 1275 arg->peer_flags |= WMI_PEER_80MHZ; 1276 1277 arg->peer_vht_rates.rx_max_rate = 1278 __le16_to_cpu(vht_cap->vht_mcs.rx_highest); 1279 arg->peer_vht_rates.rx_mcs_set = 1280 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map); 1281 arg->peer_vht_rates.tx_max_rate = 1282 __le16_to_cpu(vht_cap->vht_mcs.tx_highest); 1283 arg->peer_vht_rates.tx_mcs_set = 1284 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map); 1285 1286 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n", 1287 sta->addr, arg->peer_max_mpdu, arg->peer_flags); 1288 } 1289 1290 static void ath10k_peer_assoc_h_qos(struct ath10k *ar, 1291 struct ath10k_vif *arvif, 1292 struct ieee80211_sta *sta, 1293 struct ieee80211_bss_conf *bss_conf, 1294 struct wmi_peer_assoc_complete_arg *arg) 1295 { 1296 switch (arvif->vdev_type) { 1297 case WMI_VDEV_TYPE_AP: 1298 if (sta->wme) 1299 arg->peer_flags |= WMI_PEER_QOS; 1300 1301 if (sta->wme && sta->uapsd_queues) { 1302 arg->peer_flags |= WMI_PEER_APSD; 1303 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG; 1304 } 1305 break; 1306 case WMI_VDEV_TYPE_STA: 1307 if (bss_conf->qos) 1308 arg->peer_flags |= WMI_PEER_QOS; 1309 break; 1310 default: 1311 break; 1312 } 1313 } 1314 1315 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar, 1316 struct ath10k_vif *arvif, 1317 struct ieee80211_sta *sta, 1318 struct wmi_peer_assoc_complete_arg *arg) 1319 { 1320 enum wmi_phy_mode phymode = MODE_UNKNOWN; 1321 1322 switch (ar->hw->conf.chandef.chan->band) { 1323 case IEEE80211_BAND_2GHZ: 1324 if (sta->ht_cap.ht_supported) { 1325 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 1326 phymode = MODE_11NG_HT40; 1327 else 1328 phymode = MODE_11NG_HT20; 1329 } else { 1330 phymode = MODE_11G; 1331 } 1332 1333 break; 1334 case IEEE80211_BAND_5GHZ: 1335 /* 1336 * Check VHT first. 1337 */ 1338 if (sta->vht_cap.vht_supported) { 1339 if (sta->bandwidth == IEEE80211_STA_RX_BW_80) 1340 phymode = MODE_11AC_VHT80; 1341 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 1342 phymode = MODE_11AC_VHT40; 1343 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20) 1344 phymode = MODE_11AC_VHT20; 1345 } else if (sta->ht_cap.ht_supported) { 1346 if (sta->bandwidth == IEEE80211_STA_RX_BW_40) 1347 phymode = MODE_11NA_HT40; 1348 else 1349 phymode = MODE_11NA_HT20; 1350 } else { 1351 phymode = MODE_11A; 1352 } 1353 1354 break; 1355 default: 1356 break; 1357 } 1358 1359 ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n", 1360 sta->addr, ath10k_wmi_phymode_str(phymode)); 1361 1362 arg->peer_phymode = phymode; 1363 WARN_ON(phymode == MODE_UNKNOWN); 1364 } 1365 1366 static int ath10k_peer_assoc_prepare(struct ath10k *ar, 1367 struct ath10k_vif *arvif, 1368 struct ieee80211_sta *sta, 1369 struct ieee80211_bss_conf *bss_conf, 1370 struct wmi_peer_assoc_complete_arg *arg) 1371 { 1372 lockdep_assert_held(&ar->conf_mutex); 1373 1374 memset(arg, 0, sizeof(*arg)); 1375 1376 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg); 1377 ath10k_peer_assoc_h_crypto(ar, arvif, arg); 1378 ath10k_peer_assoc_h_rates(ar, sta, arg); 1379 ath10k_peer_assoc_h_ht(ar, sta, arg); 1380 ath10k_peer_assoc_h_vht(ar, sta, arg); 1381 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg); 1382 ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg); 1383 1384 return 0; 1385 } 1386 1387 static const u32 ath10k_smps_map[] = { 1388 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC, 1389 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC, 1390 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE, 1391 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE, 1392 }; 1393 1394 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif, 1395 const u8 *addr, 1396 const struct ieee80211_sta_ht_cap *ht_cap) 1397 { 1398 int smps; 1399 1400 if (!ht_cap->ht_supported) 1401 return 0; 1402 1403 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS; 1404 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT; 1405 1406 if (smps >= ARRAY_SIZE(ath10k_smps_map)) 1407 return -EINVAL; 1408 1409 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr, 1410 WMI_PEER_SMPS_STATE, 1411 ath10k_smps_map[smps]); 1412 } 1413 1414 /* can be called only in mac80211 callbacks due to `key_count` usage */ 1415 static void ath10k_bss_assoc(struct ieee80211_hw *hw, 1416 struct ieee80211_vif *vif, 1417 struct ieee80211_bss_conf *bss_conf) 1418 { 1419 struct ath10k *ar = hw->priv; 1420 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1421 struct ieee80211_sta_ht_cap ht_cap; 1422 struct wmi_peer_assoc_complete_arg peer_arg; 1423 struct ieee80211_sta *ap_sta; 1424 int ret; 1425 1426 lockdep_assert_held(&ar->conf_mutex); 1427 1428 rcu_read_lock(); 1429 1430 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid); 1431 if (!ap_sta) { 1432 ath10k_warn("Failed to find station entry for %pM, vdev %i\n", 1433 bss_conf->bssid, arvif->vdev_id); 1434 rcu_read_unlock(); 1435 return; 1436 } 1437 1438 /* ap_sta must be accessed only within rcu section which must be left 1439 * before calling ath10k_setup_peer_smps() which might sleep. */ 1440 ht_cap = ap_sta->ht_cap; 1441 1442 ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta, 1443 bss_conf, &peer_arg); 1444 if (ret) { 1445 ath10k_warn("Peer assoc prepare failed for %pM vdev %i\n: %d", 1446 bss_conf->bssid, arvif->vdev_id, ret); 1447 rcu_read_unlock(); 1448 return; 1449 } 1450 1451 rcu_read_unlock(); 1452 1453 ret = ath10k_wmi_peer_assoc(ar, &peer_arg); 1454 if (ret) { 1455 ath10k_warn("Peer assoc failed for %pM vdev %i\n: %d", 1456 bss_conf->bssid, arvif->vdev_id, ret); 1457 return; 1458 } 1459 1460 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap); 1461 if (ret) { 1462 ath10k_warn("failed to setup peer SMPS for vdev %i: %d\n", 1463 arvif->vdev_id, ret); 1464 return; 1465 } 1466 1467 ath10k_dbg(ATH10K_DBG_MAC, 1468 "mac vdev %d up (associated) bssid %pM aid %d\n", 1469 arvif->vdev_id, bss_conf->bssid, bss_conf->aid); 1470 1471 arvif->aid = bss_conf->aid; 1472 memcpy(arvif->bssid, bss_conf->bssid, ETH_ALEN); 1473 1474 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid); 1475 if (ret) { 1476 ath10k_warn("VDEV: %d up failed: ret %d\n", 1477 arvif->vdev_id, ret); 1478 return; 1479 } 1480 1481 arvif->is_up = true; 1482 } 1483 1484 /* 1485 * FIXME: flush TIDs 1486 */ 1487 static void ath10k_bss_disassoc(struct ieee80211_hw *hw, 1488 struct ieee80211_vif *vif) 1489 { 1490 struct ath10k *ar = hw->priv; 1491 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1492 int ret; 1493 1494 lockdep_assert_held(&ar->conf_mutex); 1495 1496 /* 1497 * For some reason, calling VDEV-DOWN before VDEV-STOP 1498 * makes the FW to send frames via HTT after disassociation. 1499 * No idea why this happens, even though VDEV-DOWN is supposed 1500 * to be analogous to link down, so just stop the VDEV. 1501 */ 1502 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n", 1503 arvif->vdev_id); 1504 1505 /* FIXME: check return value */ 1506 ret = ath10k_vdev_stop(arvif); 1507 1508 /* 1509 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and 1510 * report beacons from previously associated network through HTT. 1511 * This in turn would spam mac80211 WARN_ON if we bring down all 1512 * interfaces as it expects there is no rx when no interface is 1513 * running. 1514 */ 1515 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id); 1516 1517 /* FIXME: why don't we print error if wmi call fails? */ 1518 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id); 1519 1520 arvif->def_wep_key_idx = 0; 1521 1522 arvif->is_started = false; 1523 arvif->is_up = false; 1524 } 1525 1526 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif, 1527 struct ieee80211_sta *sta) 1528 { 1529 struct wmi_peer_assoc_complete_arg peer_arg; 1530 int ret = 0; 1531 1532 lockdep_assert_held(&ar->conf_mutex); 1533 1534 ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg); 1535 if (ret) { 1536 ath10k_warn("WMI peer assoc prepare failed for %pM vdev %i: %i\n", 1537 sta->addr, arvif->vdev_id, ret); 1538 return ret; 1539 } 1540 1541 ret = ath10k_wmi_peer_assoc(ar, &peer_arg); 1542 if (ret) { 1543 ath10k_warn("Peer assoc failed for STA %pM vdev %i: %d\n", 1544 sta->addr, arvif->vdev_id, ret); 1545 return ret; 1546 } 1547 1548 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, &sta->ht_cap); 1549 if (ret) { 1550 ath10k_warn("failed to setup peer SMPS for vdev: %d\n", ret); 1551 return ret; 1552 } 1553 1554 ret = ath10k_install_peer_wep_keys(arvif, sta->addr); 1555 if (ret) { 1556 ath10k_warn("could not install peer wep keys for vdev %i: %d\n", 1557 arvif->vdev_id, ret); 1558 return ret; 1559 } 1560 1561 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta); 1562 if (ret) { 1563 ath10k_warn("could not set qos params for STA %pM for vdev %i: %d\n", 1564 sta->addr, arvif->vdev_id, ret); 1565 return ret; 1566 } 1567 1568 return ret; 1569 } 1570 1571 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif, 1572 struct ieee80211_sta *sta) 1573 { 1574 int ret = 0; 1575 1576 lockdep_assert_held(&ar->conf_mutex); 1577 1578 ret = ath10k_clear_peer_keys(arvif, sta->addr); 1579 if (ret) { 1580 ath10k_warn("could not clear all peer wep keys for vdev %i: %d\n", 1581 arvif->vdev_id, ret); 1582 return ret; 1583 } 1584 1585 return ret; 1586 } 1587 1588 /**************/ 1589 /* Regulatory */ 1590 /**************/ 1591 1592 static int ath10k_update_channel_list(struct ath10k *ar) 1593 { 1594 struct ieee80211_hw *hw = ar->hw; 1595 struct ieee80211_supported_band **bands; 1596 enum ieee80211_band band; 1597 struct ieee80211_channel *channel; 1598 struct wmi_scan_chan_list_arg arg = {0}; 1599 struct wmi_channel_arg *ch; 1600 bool passive; 1601 int len; 1602 int ret; 1603 int i; 1604 1605 lockdep_assert_held(&ar->conf_mutex); 1606 1607 bands = hw->wiphy->bands; 1608 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 1609 if (!bands[band]) 1610 continue; 1611 1612 for (i = 0; i < bands[band]->n_channels; i++) { 1613 if (bands[band]->channels[i].flags & 1614 IEEE80211_CHAN_DISABLED) 1615 continue; 1616 1617 arg.n_channels++; 1618 } 1619 } 1620 1621 len = sizeof(struct wmi_channel_arg) * arg.n_channels; 1622 arg.channels = kzalloc(len, GFP_KERNEL); 1623 if (!arg.channels) 1624 return -ENOMEM; 1625 1626 ch = arg.channels; 1627 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 1628 if (!bands[band]) 1629 continue; 1630 1631 for (i = 0; i < bands[band]->n_channels; i++) { 1632 channel = &bands[band]->channels[i]; 1633 1634 if (channel->flags & IEEE80211_CHAN_DISABLED) 1635 continue; 1636 1637 ch->allow_ht = true; 1638 1639 /* FIXME: when should we really allow VHT? */ 1640 ch->allow_vht = true; 1641 1642 ch->allow_ibss = 1643 !(channel->flags & IEEE80211_CHAN_NO_IR); 1644 1645 ch->ht40plus = 1646 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS); 1647 1648 ch->chan_radar = 1649 !!(channel->flags & IEEE80211_CHAN_RADAR); 1650 1651 passive = channel->flags & IEEE80211_CHAN_NO_IR; 1652 ch->passive = passive; 1653 1654 ch->freq = channel->center_freq; 1655 ch->min_power = 0; 1656 ch->max_power = channel->max_power * 2; 1657 ch->max_reg_power = channel->max_reg_power * 2; 1658 ch->max_antenna_gain = channel->max_antenna_gain * 2; 1659 ch->reg_class_id = 0; /* FIXME */ 1660 1661 /* FIXME: why use only legacy modes, why not any 1662 * HT/VHT modes? Would that even make any 1663 * difference? */ 1664 if (channel->band == IEEE80211_BAND_2GHZ) 1665 ch->mode = MODE_11G; 1666 else 1667 ch->mode = MODE_11A; 1668 1669 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN)) 1670 continue; 1671 1672 ath10k_dbg(ATH10K_DBG_WMI, 1673 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n", 1674 ch - arg.channels, arg.n_channels, 1675 ch->freq, ch->max_power, ch->max_reg_power, 1676 ch->max_antenna_gain, ch->mode); 1677 1678 ch++; 1679 } 1680 } 1681 1682 ret = ath10k_wmi_scan_chan_list(ar, &arg); 1683 kfree(arg.channels); 1684 1685 return ret; 1686 } 1687 1688 static void ath10k_regd_update(struct ath10k *ar) 1689 { 1690 struct reg_dmn_pair_mapping *regpair; 1691 int ret; 1692 1693 lockdep_assert_held(&ar->conf_mutex); 1694 1695 ret = ath10k_update_channel_list(ar); 1696 if (ret) 1697 ath10k_warn("could not update channel list (%d)\n", ret); 1698 1699 regpair = ar->ath_common.regulatory.regpair; 1700 1701 /* Target allows setting up per-band regdomain but ath_common provides 1702 * a combined one only */ 1703 ret = ath10k_wmi_pdev_set_regdomain(ar, 1704 regpair->reg_domain, 1705 regpair->reg_domain, /* 2ghz */ 1706 regpair->reg_domain, /* 5ghz */ 1707 regpair->reg_2ghz_ctl, 1708 regpair->reg_5ghz_ctl); 1709 if (ret) 1710 ath10k_warn("could not set pdev regdomain (%d)\n", ret); 1711 } 1712 1713 static void ath10k_reg_notifier(struct wiphy *wiphy, 1714 struct regulatory_request *request) 1715 { 1716 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy); 1717 struct ath10k *ar = hw->priv; 1718 bool result; 1719 1720 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory); 1721 1722 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) { 1723 ath10k_dbg(ATH10K_DBG_REGULATORY, "dfs region 0x%x\n", 1724 request->dfs_region); 1725 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector, 1726 request->dfs_region); 1727 if (!result) 1728 ath10k_warn("dfs region 0x%X not supported, will trigger radar for every pulse\n", 1729 request->dfs_region); 1730 } 1731 1732 mutex_lock(&ar->conf_mutex); 1733 if (ar->state == ATH10K_STATE_ON) 1734 ath10k_regd_update(ar); 1735 mutex_unlock(&ar->conf_mutex); 1736 } 1737 1738 /***************/ 1739 /* TX handlers */ 1740 /***************/ 1741 1742 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr) 1743 { 1744 if (ieee80211_is_mgmt(hdr->frame_control)) 1745 return HTT_DATA_TX_EXT_TID_MGMT; 1746 1747 if (!ieee80211_is_data_qos(hdr->frame_control)) 1748 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST; 1749 1750 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr))) 1751 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST; 1752 1753 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK; 1754 } 1755 1756 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, 1757 struct ieee80211_tx_info *info) 1758 { 1759 if (info->control.vif) 1760 return ath10k_vif_to_arvif(info->control.vif)->vdev_id; 1761 1762 if (ar->monitor_enabled) 1763 return ar->monitor_vdev_id; 1764 1765 ath10k_warn("could not resolve vdev id\n"); 1766 return 0; 1767 } 1768 1769 /* 1770 * Frames sent to the FW have to be in "Native Wifi" format. 1771 * Strip the QoS field from the 802.11 header. 1772 */ 1773 static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw, 1774 struct ieee80211_tx_control *control, 1775 struct sk_buff *skb) 1776 { 1777 struct ieee80211_hdr *hdr = (void *)skb->data; 1778 u8 *qos_ctl; 1779 1780 if (!ieee80211_is_data_qos(hdr->frame_control)) 1781 return; 1782 1783 qos_ctl = ieee80211_get_qos_ctl(hdr); 1784 memmove(skb->data + IEEE80211_QOS_CTL_LEN, 1785 skb->data, (void *)qos_ctl - (void *)skb->data); 1786 skb_pull(skb, IEEE80211_QOS_CTL_LEN); 1787 } 1788 1789 static void ath10k_tx_wep_key_work(struct work_struct *work) 1790 { 1791 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif, 1792 wep_key_work); 1793 int ret, keyidx = arvif->def_wep_key_newidx; 1794 1795 if (arvif->def_wep_key_idx == keyidx) 1796 return; 1797 1798 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n", 1799 arvif->vdev_id, keyidx); 1800 1801 ret = ath10k_wmi_vdev_set_param(arvif->ar, 1802 arvif->vdev_id, 1803 arvif->ar->wmi.vdev_param->def_keyid, 1804 keyidx); 1805 if (ret) { 1806 ath10k_warn("could not update wep keyidx (%d)\n", ret); 1807 return; 1808 } 1809 1810 arvif->def_wep_key_idx = keyidx; 1811 } 1812 1813 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb) 1814 { 1815 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1816 struct ieee80211_vif *vif = info->control.vif; 1817 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1818 struct ath10k *ar = arvif->ar; 1819 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1820 struct ieee80211_key_conf *key = info->control.hw_key; 1821 1822 if (!ieee80211_has_protected(hdr->frame_control)) 1823 return; 1824 1825 if (!key) 1826 return; 1827 1828 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 && 1829 key->cipher != WLAN_CIPHER_SUITE_WEP104) 1830 return; 1831 1832 if (key->keyidx == arvif->def_wep_key_idx) 1833 return; 1834 1835 /* FIXME: Most likely a few frames will be TXed with an old key. Simply 1836 * queueing frames until key index is updated is not an option because 1837 * sk_buff may need more processing to be done, e.g. offchannel */ 1838 arvif->def_wep_key_newidx = key->keyidx; 1839 ieee80211_queue_work(ar->hw, &arvif->wep_key_work); 1840 } 1841 1842 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb) 1843 { 1844 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1845 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1846 struct ieee80211_vif *vif = info->control.vif; 1847 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 1848 1849 /* This is case only for P2P_GO */ 1850 if (arvif->vdev_type != WMI_VDEV_TYPE_AP || 1851 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO) 1852 return; 1853 1854 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) { 1855 spin_lock_bh(&ar->data_lock); 1856 if (arvif->u.ap.noa_data) 1857 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len, 1858 GFP_ATOMIC)) 1859 memcpy(skb_put(skb, arvif->u.ap.noa_len), 1860 arvif->u.ap.noa_data, 1861 arvif->u.ap.noa_len); 1862 spin_unlock_bh(&ar->data_lock); 1863 } 1864 } 1865 1866 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb) 1867 { 1868 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1869 int ret = 0; 1870 1871 if (ar->htt.target_version_major >= 3) { 1872 /* Since HTT 3.0 there is no separate mgmt tx command */ 1873 ret = ath10k_htt_tx(&ar->htt, skb); 1874 goto exit; 1875 } 1876 1877 if (ieee80211_is_mgmt(hdr->frame_control)) { 1878 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, 1879 ar->fw_features)) { 1880 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >= 1881 ATH10K_MAX_NUM_MGMT_PENDING) { 1882 ath10k_warn("wmi mgmt_tx queue limit reached\n"); 1883 ret = -EBUSY; 1884 goto exit; 1885 } 1886 1887 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb); 1888 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work); 1889 } else { 1890 ret = ath10k_htt_mgmt_tx(&ar->htt, skb); 1891 } 1892 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, 1893 ar->fw_features) && 1894 ieee80211_is_nullfunc(hdr->frame_control)) { 1895 /* FW does not report tx status properly for NullFunc frames 1896 * unless they are sent through mgmt tx path. mac80211 sends 1897 * those frames when it detects link/beacon loss and depends 1898 * on the tx status to be correct. */ 1899 ret = ath10k_htt_mgmt_tx(&ar->htt, skb); 1900 } else { 1901 ret = ath10k_htt_tx(&ar->htt, skb); 1902 } 1903 1904 exit: 1905 if (ret) { 1906 ath10k_warn("tx failed (%d). dropping packet.\n", ret); 1907 ieee80211_free_txskb(ar->hw, skb); 1908 } 1909 } 1910 1911 void ath10k_offchan_tx_purge(struct ath10k *ar) 1912 { 1913 struct sk_buff *skb; 1914 1915 for (;;) { 1916 skb = skb_dequeue(&ar->offchan_tx_queue); 1917 if (!skb) 1918 break; 1919 1920 ieee80211_free_txskb(ar->hw, skb); 1921 } 1922 } 1923 1924 void ath10k_offchan_tx_work(struct work_struct *work) 1925 { 1926 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work); 1927 struct ath10k_peer *peer; 1928 struct ieee80211_hdr *hdr; 1929 struct sk_buff *skb; 1930 const u8 *peer_addr; 1931 int vdev_id; 1932 int ret; 1933 1934 /* FW requirement: We must create a peer before FW will send out 1935 * an offchannel frame. Otherwise the frame will be stuck and 1936 * never transmitted. We delete the peer upon tx completion. 1937 * It is unlikely that a peer for offchannel tx will already be 1938 * present. However it may be in some rare cases so account for that. 1939 * Otherwise we might remove a legitimate peer and break stuff. */ 1940 1941 for (;;) { 1942 skb = skb_dequeue(&ar->offchan_tx_queue); 1943 if (!skb) 1944 break; 1945 1946 mutex_lock(&ar->conf_mutex); 1947 1948 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n", 1949 skb); 1950 1951 hdr = (struct ieee80211_hdr *)skb->data; 1952 peer_addr = ieee80211_get_DA(hdr); 1953 vdev_id = ATH10K_SKB_CB(skb)->vdev_id; 1954 1955 spin_lock_bh(&ar->data_lock); 1956 peer = ath10k_peer_find(ar, vdev_id, peer_addr); 1957 spin_unlock_bh(&ar->data_lock); 1958 1959 if (peer) 1960 /* FIXME: should this use ath10k_warn()? */ 1961 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n", 1962 peer_addr, vdev_id); 1963 1964 if (!peer) { 1965 ret = ath10k_peer_create(ar, vdev_id, peer_addr); 1966 if (ret) 1967 ath10k_warn("peer %pM on vdev %d not created (%d)\n", 1968 peer_addr, vdev_id, ret); 1969 } 1970 1971 spin_lock_bh(&ar->data_lock); 1972 reinit_completion(&ar->offchan_tx_completed); 1973 ar->offchan_tx_skb = skb; 1974 spin_unlock_bh(&ar->data_lock); 1975 1976 ath10k_tx_htt(ar, skb); 1977 1978 ret = wait_for_completion_timeout(&ar->offchan_tx_completed, 1979 3 * HZ); 1980 if (ret <= 0) 1981 ath10k_warn("timed out waiting for offchannel skb %p\n", 1982 skb); 1983 1984 if (!peer) { 1985 ret = ath10k_peer_delete(ar, vdev_id, peer_addr); 1986 if (ret) 1987 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n", 1988 peer_addr, vdev_id, ret); 1989 } 1990 1991 mutex_unlock(&ar->conf_mutex); 1992 } 1993 } 1994 1995 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar) 1996 { 1997 struct sk_buff *skb; 1998 1999 for (;;) { 2000 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 2001 if (!skb) 2002 break; 2003 2004 ieee80211_free_txskb(ar->hw, skb); 2005 } 2006 } 2007 2008 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work) 2009 { 2010 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work); 2011 struct sk_buff *skb; 2012 int ret; 2013 2014 for (;;) { 2015 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue); 2016 if (!skb) 2017 break; 2018 2019 ret = ath10k_wmi_mgmt_tx(ar, skb); 2020 if (ret) { 2021 ath10k_warn("wmi mgmt_tx failed (%d)\n", ret); 2022 ieee80211_free_txskb(ar->hw, skb); 2023 } 2024 } 2025 } 2026 2027 /************/ 2028 /* Scanning */ 2029 /************/ 2030 2031 /* 2032 * This gets called if we dont get a heart-beat during scan. 2033 * This may indicate the FW has hung and we need to abort the 2034 * scan manually to prevent cancel_hw_scan() from deadlocking 2035 */ 2036 void ath10k_reset_scan(unsigned long ptr) 2037 { 2038 struct ath10k *ar = (struct ath10k *)ptr; 2039 2040 spin_lock_bh(&ar->data_lock); 2041 if (!ar->scan.in_progress) { 2042 spin_unlock_bh(&ar->data_lock); 2043 return; 2044 } 2045 2046 ath10k_warn("scan timeout. resetting. fw issue?\n"); 2047 2048 if (ar->scan.is_roc) 2049 ieee80211_remain_on_channel_expired(ar->hw); 2050 else 2051 ieee80211_scan_completed(ar->hw, 1 /* aborted */); 2052 2053 ar->scan.in_progress = false; 2054 complete_all(&ar->scan.completed); 2055 spin_unlock_bh(&ar->data_lock); 2056 } 2057 2058 static int ath10k_abort_scan(struct ath10k *ar) 2059 { 2060 struct wmi_stop_scan_arg arg = { 2061 .req_id = 1, /* FIXME */ 2062 .req_type = WMI_SCAN_STOP_ONE, 2063 .u.scan_id = ATH10K_SCAN_ID, 2064 }; 2065 int ret; 2066 2067 lockdep_assert_held(&ar->conf_mutex); 2068 2069 del_timer_sync(&ar->scan.timeout); 2070 2071 spin_lock_bh(&ar->data_lock); 2072 if (!ar->scan.in_progress) { 2073 spin_unlock_bh(&ar->data_lock); 2074 return 0; 2075 } 2076 2077 ar->scan.aborting = true; 2078 spin_unlock_bh(&ar->data_lock); 2079 2080 ret = ath10k_wmi_stop_scan(ar, &arg); 2081 if (ret) { 2082 ath10k_warn("could not submit wmi stop scan (%d)\n", ret); 2083 spin_lock_bh(&ar->data_lock); 2084 ar->scan.in_progress = false; 2085 ath10k_offchan_tx_purge(ar); 2086 spin_unlock_bh(&ar->data_lock); 2087 return -EIO; 2088 } 2089 2090 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ); 2091 if (ret == 0) 2092 ath10k_warn("timed out while waiting for scan to stop\n"); 2093 2094 /* scan completion may be done right after we timeout here, so let's 2095 * check the in_progress and tell mac80211 scan is completed. if we 2096 * don't do that and FW fails to send us scan completion indication 2097 * then userspace won't be able to scan anymore */ 2098 ret = 0; 2099 2100 spin_lock_bh(&ar->data_lock); 2101 if (ar->scan.in_progress) { 2102 ath10k_warn("could not stop scan. its still in progress\n"); 2103 ar->scan.in_progress = false; 2104 ath10k_offchan_tx_purge(ar); 2105 ret = -ETIMEDOUT; 2106 } 2107 spin_unlock_bh(&ar->data_lock); 2108 2109 return ret; 2110 } 2111 2112 static int ath10k_start_scan(struct ath10k *ar, 2113 const struct wmi_start_scan_arg *arg) 2114 { 2115 int ret; 2116 2117 lockdep_assert_held(&ar->conf_mutex); 2118 2119 ret = ath10k_wmi_start_scan(ar, arg); 2120 if (ret) 2121 return ret; 2122 2123 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ); 2124 if (ret == 0) { 2125 ath10k_abort_scan(ar); 2126 return ret; 2127 } 2128 2129 /* the scan can complete earlier, before we even 2130 * start the timer. in that case the timer handler 2131 * checks ar->scan.in_progress and bails out if its 2132 * false. Add a 200ms margin to account event/command 2133 * processing. */ 2134 mod_timer(&ar->scan.timeout, jiffies + 2135 msecs_to_jiffies(arg->max_scan_time+200)); 2136 return 0; 2137 } 2138 2139 /**********************/ 2140 /* mac80211 callbacks */ 2141 /**********************/ 2142 2143 static void ath10k_tx(struct ieee80211_hw *hw, 2144 struct ieee80211_tx_control *control, 2145 struct sk_buff *skb) 2146 { 2147 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 2148 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 2149 struct ath10k *ar = hw->priv; 2150 u8 tid, vdev_id; 2151 2152 /* We should disable CCK RATE due to P2P */ 2153 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE) 2154 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n"); 2155 2156 /* we must calculate tid before we apply qos workaround 2157 * as we'd lose the qos control field */ 2158 tid = ath10k_tx_h_get_tid(hdr); 2159 vdev_id = ath10k_tx_h_get_vdev_id(ar, info); 2160 2161 /* it makes no sense to process injected frames like that */ 2162 if (info->control.vif && 2163 info->control.vif->type != NL80211_IFTYPE_MONITOR) { 2164 ath10k_tx_h_qos_workaround(hw, control, skb); 2165 ath10k_tx_h_update_wep_key(skb); 2166 ath10k_tx_h_add_p2p_noa_ie(ar, skb); 2167 ath10k_tx_h_seq_no(skb); 2168 } 2169 2170 ATH10K_SKB_CB(skb)->vdev_id = vdev_id; 2171 ATH10K_SKB_CB(skb)->htt.is_offchan = false; 2172 ATH10K_SKB_CB(skb)->htt.tid = tid; 2173 2174 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) { 2175 spin_lock_bh(&ar->data_lock); 2176 ATH10K_SKB_CB(skb)->htt.is_offchan = true; 2177 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id; 2178 spin_unlock_bh(&ar->data_lock); 2179 2180 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb); 2181 2182 skb_queue_tail(&ar->offchan_tx_queue, skb); 2183 ieee80211_queue_work(hw, &ar->offchan_tx_work); 2184 return; 2185 } 2186 2187 ath10k_tx_htt(ar, skb); 2188 } 2189 2190 /* 2191 * Initialize various parameters with default vaules. 2192 */ 2193 void ath10k_halt(struct ath10k *ar) 2194 { 2195 lockdep_assert_held(&ar->conf_mutex); 2196 2197 ath10k_stop_cac(ar); 2198 del_timer_sync(&ar->scan.timeout); 2199 ath10k_offchan_tx_purge(ar); 2200 ath10k_mgmt_over_wmi_tx_purge(ar); 2201 ath10k_peer_cleanup_all(ar); 2202 ath10k_core_stop(ar); 2203 ath10k_hif_power_down(ar); 2204 2205 spin_lock_bh(&ar->data_lock); 2206 if (ar->scan.in_progress) { 2207 del_timer(&ar->scan.timeout); 2208 ar->scan.in_progress = false; 2209 ieee80211_scan_completed(ar->hw, true); 2210 } 2211 spin_unlock_bh(&ar->data_lock); 2212 } 2213 2214 static int ath10k_start(struct ieee80211_hw *hw) 2215 { 2216 struct ath10k *ar = hw->priv; 2217 int ret = 0; 2218 2219 mutex_lock(&ar->conf_mutex); 2220 2221 if (ar->state != ATH10K_STATE_OFF && 2222 ar->state != ATH10K_STATE_RESTARTING) { 2223 ret = -EINVAL; 2224 goto exit; 2225 } 2226 2227 ret = ath10k_hif_power_up(ar); 2228 if (ret) { 2229 ath10k_err("could not init hif (%d)\n", ret); 2230 ar->state = ATH10K_STATE_OFF; 2231 goto exit; 2232 } 2233 2234 ret = ath10k_core_start(ar); 2235 if (ret) { 2236 ath10k_err("could not init core (%d)\n", ret); 2237 ath10k_hif_power_down(ar); 2238 ar->state = ATH10K_STATE_OFF; 2239 goto exit; 2240 } 2241 2242 if (ar->state == ATH10K_STATE_OFF) 2243 ar->state = ATH10K_STATE_ON; 2244 else if (ar->state == ATH10K_STATE_RESTARTING) 2245 ar->state = ATH10K_STATE_RESTARTED; 2246 2247 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1); 2248 if (ret) 2249 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n", 2250 ret); 2251 2252 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1); 2253 if (ret) 2254 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n", 2255 ret); 2256 2257 /* 2258 * By default FW set ARP frames ac to voice (6). In that case ARP 2259 * exchange is not working properly for UAPSD enabled AP. ARP requests 2260 * which arrives with access category 0 are processed by network stack 2261 * and send back with access category 0, but FW changes access category 2262 * to 6. Set ARP frames access category to best effort (0) solves 2263 * this problem. 2264 */ 2265 2266 ret = ath10k_wmi_pdev_set_param(ar, 2267 ar->wmi.pdev_param->arp_ac_override, 0); 2268 if (ret) { 2269 ath10k_warn("could not set arp ac override parameter: %d\n", 2270 ret); 2271 goto exit; 2272 } 2273 2274 ath10k_regd_update(ar); 2275 ret = 0; 2276 2277 exit: 2278 mutex_unlock(&ar->conf_mutex); 2279 return ret; 2280 } 2281 2282 static void ath10k_stop(struct ieee80211_hw *hw) 2283 { 2284 struct ath10k *ar = hw->priv; 2285 2286 mutex_lock(&ar->conf_mutex); 2287 if (ar->state == ATH10K_STATE_ON || 2288 ar->state == ATH10K_STATE_RESTARTED || 2289 ar->state == ATH10K_STATE_WEDGED) 2290 ath10k_halt(ar); 2291 2292 ar->state = ATH10K_STATE_OFF; 2293 mutex_unlock(&ar->conf_mutex); 2294 2295 ath10k_mgmt_over_wmi_tx_purge(ar); 2296 2297 cancel_work_sync(&ar->offchan_tx_work); 2298 cancel_work_sync(&ar->wmi_mgmt_tx_work); 2299 cancel_work_sync(&ar->restart_work); 2300 } 2301 2302 static int ath10k_config_ps(struct ath10k *ar) 2303 { 2304 struct ath10k_vif *arvif; 2305 int ret = 0; 2306 2307 lockdep_assert_held(&ar->conf_mutex); 2308 2309 list_for_each_entry(arvif, &ar->arvifs, list) { 2310 ret = ath10k_mac_vif_setup_ps(arvif); 2311 if (ret) { 2312 ath10k_warn("could not setup powersave (%d)\n", ret); 2313 break; 2314 } 2315 } 2316 2317 return ret; 2318 } 2319 2320 static const char *chandef_get_width(enum nl80211_chan_width width) 2321 { 2322 switch (width) { 2323 case NL80211_CHAN_WIDTH_20_NOHT: 2324 return "20 (noht)"; 2325 case NL80211_CHAN_WIDTH_20: 2326 return "20"; 2327 case NL80211_CHAN_WIDTH_40: 2328 return "40"; 2329 case NL80211_CHAN_WIDTH_80: 2330 return "80"; 2331 case NL80211_CHAN_WIDTH_80P80: 2332 return "80+80"; 2333 case NL80211_CHAN_WIDTH_160: 2334 return "160"; 2335 case NL80211_CHAN_WIDTH_5: 2336 return "5"; 2337 case NL80211_CHAN_WIDTH_10: 2338 return "10"; 2339 } 2340 return "?"; 2341 } 2342 2343 static void ath10k_config_chan(struct ath10k *ar) 2344 { 2345 struct ath10k_vif *arvif; 2346 bool monitor_was_enabled; 2347 int ret; 2348 2349 lockdep_assert_held(&ar->conf_mutex); 2350 2351 ath10k_dbg(ATH10K_DBG_MAC, 2352 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n", 2353 ar->chandef.chan->center_freq, 2354 ar->chandef.center_freq1, 2355 ar->chandef.center_freq2, 2356 chandef_get_width(ar->chandef.width)); 2357 2358 /* First stop monitor interface. Some FW versions crash if there's a 2359 * lone monitor interface. */ 2360 monitor_was_enabled = ar->monitor_enabled; 2361 2362 if (ar->monitor_enabled) 2363 ath10k_monitor_stop(ar); 2364 2365 list_for_each_entry(arvif, &ar->arvifs, list) { 2366 if (!arvif->is_started) 2367 continue; 2368 2369 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2370 continue; 2371 2372 ret = ath10k_vdev_stop(arvif); 2373 if (ret) { 2374 ath10k_warn("could not stop vdev %d (%d)\n", 2375 arvif->vdev_id, ret); 2376 continue; 2377 } 2378 } 2379 2380 /* all vdevs are now stopped - now attempt to restart them */ 2381 2382 list_for_each_entry(arvif, &ar->arvifs, list) { 2383 if (!arvif->is_started) 2384 continue; 2385 2386 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2387 continue; 2388 2389 ret = ath10k_vdev_start(arvif); 2390 if (ret) { 2391 ath10k_warn("could not start vdev %d (%d)\n", 2392 arvif->vdev_id, ret); 2393 continue; 2394 } 2395 2396 if (!arvif->is_up) 2397 continue; 2398 2399 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid, 2400 arvif->bssid); 2401 if (ret) { 2402 ath10k_warn("could not bring vdev up %d (%d)\n", 2403 arvif->vdev_id, ret); 2404 continue; 2405 } 2406 } 2407 2408 if (monitor_was_enabled) 2409 ath10k_monitor_start(ar, ar->monitor_vdev_id); 2410 } 2411 2412 static int ath10k_config(struct ieee80211_hw *hw, u32 changed) 2413 { 2414 struct ath10k *ar = hw->priv; 2415 struct ieee80211_conf *conf = &hw->conf; 2416 int ret = 0; 2417 u32 param; 2418 2419 mutex_lock(&ar->conf_mutex); 2420 2421 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 2422 ath10k_dbg(ATH10K_DBG_MAC, 2423 "mac config channel %d mhz flags 0x%x\n", 2424 conf->chandef.chan->center_freq, 2425 conf->chandef.chan->flags); 2426 2427 spin_lock_bh(&ar->data_lock); 2428 ar->rx_channel = conf->chandef.chan; 2429 spin_unlock_bh(&ar->data_lock); 2430 2431 ath10k_config_radar_detection(ar); 2432 2433 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) { 2434 ar->chandef = conf->chandef; 2435 ath10k_config_chan(ar); 2436 } 2437 } 2438 2439 if (changed & IEEE80211_CONF_CHANGE_POWER) { 2440 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n", 2441 hw->conf.power_level); 2442 2443 param = ar->wmi.pdev_param->txpower_limit2g; 2444 ret = ath10k_wmi_pdev_set_param(ar, param, 2445 hw->conf.power_level * 2); 2446 if (ret) 2447 ath10k_warn("mac failed to set 2g txpower %d (%d)\n", 2448 hw->conf.power_level, ret); 2449 2450 param = ar->wmi.pdev_param->txpower_limit5g; 2451 ret = ath10k_wmi_pdev_set_param(ar, param, 2452 hw->conf.power_level * 2); 2453 if (ret) 2454 ath10k_warn("mac failed to set 5g txpower %d (%d)\n", 2455 hw->conf.power_level, ret); 2456 } 2457 2458 if (changed & IEEE80211_CONF_CHANGE_PS) 2459 ath10k_config_ps(ar); 2460 2461 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 2462 if (conf->flags & IEEE80211_CONF_MONITOR) 2463 ret = ath10k_monitor_create(ar); 2464 else 2465 ret = ath10k_monitor_destroy(ar); 2466 } 2467 2468 mutex_unlock(&ar->conf_mutex); 2469 return ret; 2470 } 2471 2472 /* 2473 * TODO: 2474 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE, 2475 * because we will send mgmt frames without CCK. This requirement 2476 * for P2P_FIND/GO_NEG should be handled by checking CCK flag 2477 * in the TX packet. 2478 */ 2479 static int ath10k_add_interface(struct ieee80211_hw *hw, 2480 struct ieee80211_vif *vif) 2481 { 2482 struct ath10k *ar = hw->priv; 2483 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2484 enum wmi_sta_powersave_param param; 2485 int ret = 0; 2486 u32 value; 2487 int bit; 2488 u32 vdev_param; 2489 2490 mutex_lock(&ar->conf_mutex); 2491 2492 memset(arvif, 0, sizeof(*arvif)); 2493 2494 arvif->ar = ar; 2495 arvif->vif = vif; 2496 2497 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work); 2498 INIT_LIST_HEAD(&arvif->list); 2499 2500 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) { 2501 ath10k_warn("Only one monitor interface allowed\n"); 2502 ret = -EBUSY; 2503 goto err; 2504 } 2505 2506 bit = ffs(ar->free_vdev_map); 2507 if (bit == 0) { 2508 ret = -EBUSY; 2509 goto err; 2510 } 2511 2512 arvif->vdev_id = bit - 1; 2513 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE; 2514 2515 if (ar->p2p) 2516 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE; 2517 2518 switch (vif->type) { 2519 case NL80211_IFTYPE_UNSPECIFIED: 2520 case NL80211_IFTYPE_STATION: 2521 arvif->vdev_type = WMI_VDEV_TYPE_STA; 2522 if (vif->p2p) 2523 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT; 2524 break; 2525 case NL80211_IFTYPE_ADHOC: 2526 arvif->vdev_type = WMI_VDEV_TYPE_IBSS; 2527 break; 2528 case NL80211_IFTYPE_AP: 2529 arvif->vdev_type = WMI_VDEV_TYPE_AP; 2530 2531 if (vif->p2p) 2532 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO; 2533 break; 2534 case NL80211_IFTYPE_MONITOR: 2535 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR; 2536 break; 2537 default: 2538 WARN_ON(1); 2539 break; 2540 } 2541 2542 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n", 2543 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype); 2544 2545 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type, 2546 arvif->vdev_subtype, vif->addr); 2547 if (ret) { 2548 ath10k_warn("WMI vdev %i create failed: ret %d\n", 2549 arvif->vdev_id, ret); 2550 goto err; 2551 } 2552 2553 ar->free_vdev_map &= ~BIT(arvif->vdev_id); 2554 list_add(&arvif->list, &ar->arvifs); 2555 2556 vdev_param = ar->wmi.vdev_param->def_keyid; 2557 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param, 2558 arvif->def_wep_key_idx); 2559 if (ret) { 2560 ath10k_warn("Failed to set vdev %i default keyid: %d\n", 2561 arvif->vdev_id, ret); 2562 goto err_vdev_delete; 2563 } 2564 2565 vdev_param = ar->wmi.vdev_param->tx_encap_type; 2566 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 2567 ATH10K_HW_TXRX_NATIVE_WIFI); 2568 /* 10.X firmware does not support this VDEV parameter. Do not warn */ 2569 if (ret && ret != -EOPNOTSUPP) { 2570 ath10k_warn("Failed to set vdev %i TX encap: %d\n", 2571 arvif->vdev_id, ret); 2572 goto err_vdev_delete; 2573 } 2574 2575 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 2576 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr); 2577 if (ret) { 2578 ath10k_warn("Failed to create vdev %i peer for AP: %d\n", 2579 arvif->vdev_id, ret); 2580 goto err_vdev_delete; 2581 } 2582 2583 ret = ath10k_mac_set_kickout(arvif); 2584 if (ret) { 2585 ath10k_warn("Failed to set vdev %i kickout parameters: %d\n", 2586 arvif->vdev_id, ret); 2587 goto err_peer_delete; 2588 } 2589 } 2590 2591 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) { 2592 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY; 2593 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 2594 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2595 param, value); 2596 if (ret) { 2597 ath10k_warn("Failed to set vdev %i RX wake policy: %d\n", 2598 arvif->vdev_id, ret); 2599 goto err_peer_delete; 2600 } 2601 2602 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD; 2603 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS; 2604 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2605 param, value); 2606 if (ret) { 2607 ath10k_warn("Failed to set vdev %i TX wake thresh: %d\n", 2608 arvif->vdev_id, ret); 2609 goto err_peer_delete; 2610 } 2611 2612 param = WMI_STA_PS_PARAM_PSPOLL_COUNT; 2613 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX; 2614 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 2615 param, value); 2616 if (ret) { 2617 ath10k_warn("Failed to set vdev %i PSPOLL count: %d\n", 2618 arvif->vdev_id, ret); 2619 goto err_peer_delete; 2620 } 2621 } 2622 2623 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold); 2624 if (ret) { 2625 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n", 2626 arvif->vdev_id, ret); 2627 goto err_peer_delete; 2628 } 2629 2630 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold); 2631 if (ret) { 2632 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n", 2633 arvif->vdev_id, ret); 2634 goto err_peer_delete; 2635 } 2636 2637 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2638 ar->monitor_present = true; 2639 2640 mutex_unlock(&ar->conf_mutex); 2641 return 0; 2642 2643 err_peer_delete: 2644 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) 2645 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr); 2646 2647 err_vdev_delete: 2648 ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 2649 ar->free_vdev_map &= ~BIT(arvif->vdev_id); 2650 list_del(&arvif->list); 2651 2652 err: 2653 mutex_unlock(&ar->conf_mutex); 2654 2655 return ret; 2656 } 2657 2658 static void ath10k_remove_interface(struct ieee80211_hw *hw, 2659 struct ieee80211_vif *vif) 2660 { 2661 struct ath10k *ar = hw->priv; 2662 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2663 int ret; 2664 2665 mutex_lock(&ar->conf_mutex); 2666 2667 cancel_work_sync(&arvif->wep_key_work); 2668 2669 spin_lock_bh(&ar->data_lock); 2670 if (arvif->beacon) { 2671 dev_kfree_skb_any(arvif->beacon); 2672 arvif->beacon = NULL; 2673 } 2674 spin_unlock_bh(&ar->data_lock); 2675 2676 ar->free_vdev_map |= 1 << (arvif->vdev_id); 2677 list_del(&arvif->list); 2678 2679 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) { 2680 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr); 2681 if (ret) 2682 ath10k_warn("Failed to remove peer for AP vdev %i: %d\n", 2683 arvif->vdev_id, ret); 2684 2685 kfree(arvif->u.ap.noa_data); 2686 } 2687 2688 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n", 2689 arvif->vdev_id); 2690 2691 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id); 2692 if (ret) 2693 ath10k_warn("WMI vdev %i delete failed: %d\n", 2694 arvif->vdev_id, ret); 2695 2696 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR) 2697 ar->monitor_present = false; 2698 2699 ath10k_peer_cleanup(ar, arvif->vdev_id); 2700 2701 mutex_unlock(&ar->conf_mutex); 2702 } 2703 2704 /* 2705 * FIXME: Has to be verified. 2706 */ 2707 #define SUPPORTED_FILTERS \ 2708 (FIF_PROMISC_IN_BSS | \ 2709 FIF_ALLMULTI | \ 2710 FIF_CONTROL | \ 2711 FIF_PSPOLL | \ 2712 FIF_OTHER_BSS | \ 2713 FIF_BCN_PRBRESP_PROMISC | \ 2714 FIF_PROBE_REQ | \ 2715 FIF_FCSFAIL) 2716 2717 static void ath10k_configure_filter(struct ieee80211_hw *hw, 2718 unsigned int changed_flags, 2719 unsigned int *total_flags, 2720 u64 multicast) 2721 { 2722 struct ath10k *ar = hw->priv; 2723 int ret; 2724 2725 mutex_lock(&ar->conf_mutex); 2726 2727 changed_flags &= SUPPORTED_FILTERS; 2728 *total_flags &= SUPPORTED_FILTERS; 2729 ar->filter_flags = *total_flags; 2730 2731 /* Monitor must not be started if it wasn't created first. 2732 * Promiscuous mode may be started on a non-monitor interface - in 2733 * such case the monitor vdev is not created so starting the 2734 * monitor makes no sense. Since ath10k uses no special RX filters 2735 * (only BSS filter in STA mode) there's no need for any special 2736 * action here. */ 2737 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) && 2738 !ar->monitor_enabled && ar->monitor_present) { 2739 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d start\n", 2740 ar->monitor_vdev_id); 2741 2742 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id); 2743 if (ret) 2744 ath10k_warn("Unable to start monitor mode\n"); 2745 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) && 2746 ar->monitor_enabled && ar->monitor_present) { 2747 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d stop\n", 2748 ar->monitor_vdev_id); 2749 2750 ret = ath10k_monitor_stop(ar); 2751 if (ret) 2752 ath10k_warn("Unable to stop monitor mode\n"); 2753 } 2754 2755 mutex_unlock(&ar->conf_mutex); 2756 } 2757 2758 static void ath10k_bss_info_changed(struct ieee80211_hw *hw, 2759 struct ieee80211_vif *vif, 2760 struct ieee80211_bss_conf *info, 2761 u32 changed) 2762 { 2763 struct ath10k *ar = hw->priv; 2764 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2765 int ret = 0; 2766 u32 vdev_param, pdev_param; 2767 2768 mutex_lock(&ar->conf_mutex); 2769 2770 if (changed & BSS_CHANGED_IBSS) 2771 ath10k_control_ibss(arvif, info, vif->addr); 2772 2773 if (changed & BSS_CHANGED_BEACON_INT) { 2774 arvif->beacon_interval = info->beacon_int; 2775 vdev_param = ar->wmi.vdev_param->beacon_interval; 2776 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 2777 arvif->beacon_interval); 2778 ath10k_dbg(ATH10K_DBG_MAC, 2779 "mac vdev %d beacon_interval %d\n", 2780 arvif->vdev_id, arvif->beacon_interval); 2781 2782 if (ret) 2783 ath10k_warn("Failed to set beacon interval for vdev %d: %i\n", 2784 arvif->vdev_id, ret); 2785 } 2786 2787 if (changed & BSS_CHANGED_BEACON) { 2788 ath10k_dbg(ATH10K_DBG_MAC, 2789 "vdev %d set beacon tx mode to staggered\n", 2790 arvif->vdev_id); 2791 2792 pdev_param = ar->wmi.pdev_param->beacon_tx_mode; 2793 ret = ath10k_wmi_pdev_set_param(ar, pdev_param, 2794 WMI_BEACON_STAGGERED_MODE); 2795 if (ret) 2796 ath10k_warn("Failed to set beacon mode for vdev %d: %i\n", 2797 arvif->vdev_id, ret); 2798 } 2799 2800 if (changed & BSS_CHANGED_BEACON_INFO) { 2801 arvif->dtim_period = info->dtim_period; 2802 2803 ath10k_dbg(ATH10K_DBG_MAC, 2804 "mac vdev %d dtim_period %d\n", 2805 arvif->vdev_id, arvif->dtim_period); 2806 2807 vdev_param = ar->wmi.vdev_param->dtim_period; 2808 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 2809 arvif->dtim_period); 2810 if (ret) 2811 ath10k_warn("Failed to set dtim period for vdev %d: %i\n", 2812 arvif->vdev_id, ret); 2813 } 2814 2815 if (changed & BSS_CHANGED_SSID && 2816 vif->type == NL80211_IFTYPE_AP) { 2817 arvif->u.ap.ssid_len = info->ssid_len; 2818 if (info->ssid_len) 2819 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len); 2820 arvif->u.ap.hidden_ssid = info->hidden_ssid; 2821 } 2822 2823 if (changed & BSS_CHANGED_BSSID) { 2824 if (!is_zero_ether_addr(info->bssid)) { 2825 ath10k_dbg(ATH10K_DBG_MAC, 2826 "mac vdev %d create peer %pM\n", 2827 arvif->vdev_id, info->bssid); 2828 2829 ret = ath10k_peer_create(ar, arvif->vdev_id, 2830 info->bssid); 2831 if (ret) 2832 ath10k_warn("Failed to add peer %pM for vdev %d when changing bssid: %i\n", 2833 info->bssid, arvif->vdev_id, ret); 2834 2835 if (vif->type == NL80211_IFTYPE_STATION) { 2836 /* 2837 * this is never erased as we it for crypto key 2838 * clearing; this is FW requirement 2839 */ 2840 memcpy(arvif->bssid, info->bssid, ETH_ALEN); 2841 2842 ath10k_dbg(ATH10K_DBG_MAC, 2843 "mac vdev %d start %pM\n", 2844 arvif->vdev_id, info->bssid); 2845 2846 ret = ath10k_vdev_start(arvif); 2847 if (ret) { 2848 ath10k_warn("failed to start vdev %i: %d\n", 2849 arvif->vdev_id, ret); 2850 goto exit; 2851 } 2852 2853 arvif->is_started = true; 2854 } 2855 2856 /* 2857 * Mac80211 does not keep IBSS bssid when leaving IBSS, 2858 * so driver need to store it. It is needed when leaving 2859 * IBSS in order to remove BSSID peer. 2860 */ 2861 if (vif->type == NL80211_IFTYPE_ADHOC) 2862 memcpy(arvif->bssid, info->bssid, 2863 ETH_ALEN); 2864 } 2865 } 2866 2867 if (changed & BSS_CHANGED_BEACON_ENABLED) 2868 ath10k_control_beaconing(arvif, info); 2869 2870 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 2871 u32 cts_prot; 2872 if (info->use_cts_prot) 2873 cts_prot = 1; 2874 else 2875 cts_prot = 0; 2876 2877 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n", 2878 arvif->vdev_id, cts_prot); 2879 2880 vdev_param = ar->wmi.vdev_param->enable_rtscts; 2881 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 2882 cts_prot); 2883 if (ret) 2884 ath10k_warn("Failed to set CTS prot for vdev %d: %d\n", 2885 arvif->vdev_id, ret); 2886 } 2887 2888 if (changed & BSS_CHANGED_ERP_SLOT) { 2889 u32 slottime; 2890 if (info->use_short_slot) 2891 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */ 2892 2893 else 2894 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */ 2895 2896 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n", 2897 arvif->vdev_id, slottime); 2898 2899 vdev_param = ar->wmi.vdev_param->slot_time; 2900 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 2901 slottime); 2902 if (ret) 2903 ath10k_warn("Failed to set erp slot for vdev %d: %i\n", 2904 arvif->vdev_id, ret); 2905 } 2906 2907 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 2908 u32 preamble; 2909 if (info->use_short_preamble) 2910 preamble = WMI_VDEV_PREAMBLE_SHORT; 2911 else 2912 preamble = WMI_VDEV_PREAMBLE_LONG; 2913 2914 ath10k_dbg(ATH10K_DBG_MAC, 2915 "mac vdev %d preamble %dn", 2916 arvif->vdev_id, preamble); 2917 2918 vdev_param = ar->wmi.vdev_param->preamble; 2919 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 2920 preamble); 2921 if (ret) 2922 ath10k_warn("Failed to set preamble for vdev %d: %i\n", 2923 arvif->vdev_id, ret); 2924 } 2925 2926 if (changed & BSS_CHANGED_ASSOC) { 2927 if (info->assoc) 2928 ath10k_bss_assoc(hw, vif, info); 2929 } 2930 2931 exit: 2932 mutex_unlock(&ar->conf_mutex); 2933 } 2934 2935 static int ath10k_hw_scan(struct ieee80211_hw *hw, 2936 struct ieee80211_vif *vif, 2937 struct cfg80211_scan_request *req) 2938 { 2939 struct ath10k *ar = hw->priv; 2940 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 2941 struct wmi_start_scan_arg arg; 2942 int ret = 0; 2943 int i; 2944 2945 mutex_lock(&ar->conf_mutex); 2946 2947 spin_lock_bh(&ar->data_lock); 2948 if (ar->scan.in_progress) { 2949 spin_unlock_bh(&ar->data_lock); 2950 ret = -EBUSY; 2951 goto exit; 2952 } 2953 2954 reinit_completion(&ar->scan.started); 2955 reinit_completion(&ar->scan.completed); 2956 ar->scan.in_progress = true; 2957 ar->scan.aborting = false; 2958 ar->scan.is_roc = false; 2959 ar->scan.vdev_id = arvif->vdev_id; 2960 spin_unlock_bh(&ar->data_lock); 2961 2962 memset(&arg, 0, sizeof(arg)); 2963 ath10k_wmi_start_scan_init(ar, &arg); 2964 arg.vdev_id = arvif->vdev_id; 2965 arg.scan_id = ATH10K_SCAN_ID; 2966 2967 if (!req->no_cck) 2968 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES; 2969 2970 if (req->ie_len) { 2971 arg.ie_len = req->ie_len; 2972 memcpy(arg.ie, req->ie, arg.ie_len); 2973 } 2974 2975 if (req->n_ssids) { 2976 arg.n_ssids = req->n_ssids; 2977 for (i = 0; i < arg.n_ssids; i++) { 2978 arg.ssids[i].len = req->ssids[i].ssid_len; 2979 arg.ssids[i].ssid = req->ssids[i].ssid; 2980 } 2981 } else { 2982 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 2983 } 2984 2985 if (req->n_channels) { 2986 arg.n_channels = req->n_channels; 2987 for (i = 0; i < arg.n_channels; i++) 2988 arg.channels[i] = req->channels[i]->center_freq; 2989 } 2990 2991 ret = ath10k_start_scan(ar, &arg); 2992 if (ret) { 2993 ath10k_warn("could not start hw scan (%d)\n", ret); 2994 spin_lock_bh(&ar->data_lock); 2995 ar->scan.in_progress = false; 2996 spin_unlock_bh(&ar->data_lock); 2997 } 2998 2999 exit: 3000 mutex_unlock(&ar->conf_mutex); 3001 return ret; 3002 } 3003 3004 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw, 3005 struct ieee80211_vif *vif) 3006 { 3007 struct ath10k *ar = hw->priv; 3008 int ret; 3009 3010 mutex_lock(&ar->conf_mutex); 3011 ret = ath10k_abort_scan(ar); 3012 if (ret) { 3013 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n", 3014 ret); 3015 ieee80211_scan_completed(hw, 1 /* aborted */); 3016 } 3017 mutex_unlock(&ar->conf_mutex); 3018 } 3019 3020 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar, 3021 struct ath10k_vif *arvif, 3022 enum set_key_cmd cmd, 3023 struct ieee80211_key_conf *key) 3024 { 3025 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid; 3026 int ret; 3027 3028 /* 10.1 firmware branch requires default key index to be set to group 3029 * key index after installing it. Otherwise FW/HW Txes corrupted 3030 * frames with multi-vif APs. This is not required for main firmware 3031 * branch (e.g. 636). 3032 * 3033 * FIXME: This has been tested only in AP. It remains unknown if this 3034 * is required for multi-vif STA interfaces on 10.1 */ 3035 3036 if (arvif->vdev_type != WMI_VDEV_TYPE_AP) 3037 return; 3038 3039 if (key->cipher == WLAN_CIPHER_SUITE_WEP40) 3040 return; 3041 3042 if (key->cipher == WLAN_CIPHER_SUITE_WEP104) 3043 return; 3044 3045 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 3046 return; 3047 3048 if (cmd != SET_KEY) 3049 return; 3050 3051 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 3052 key->keyidx); 3053 if (ret) 3054 ath10k_warn("failed to set vdev %i group key as default key: %d\n", 3055 arvif->vdev_id, ret); 3056 } 3057 3058 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 3059 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 3060 struct ieee80211_key_conf *key) 3061 { 3062 struct ath10k *ar = hw->priv; 3063 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3064 struct ath10k_peer *peer; 3065 const u8 *peer_addr; 3066 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 || 3067 key->cipher == WLAN_CIPHER_SUITE_WEP104; 3068 int ret = 0; 3069 3070 if (key->keyidx > WMI_MAX_KEY_INDEX) 3071 return -ENOSPC; 3072 3073 mutex_lock(&ar->conf_mutex); 3074 3075 if (sta) 3076 peer_addr = sta->addr; 3077 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) 3078 peer_addr = vif->bss_conf.bssid; 3079 else 3080 peer_addr = vif->addr; 3081 3082 key->hw_key_idx = key->keyidx; 3083 3084 /* the peer should not disappear in mid-way (unless FW goes awry) since 3085 * we already hold conf_mutex. we just make sure its there now. */ 3086 spin_lock_bh(&ar->data_lock); 3087 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 3088 spin_unlock_bh(&ar->data_lock); 3089 3090 if (!peer) { 3091 if (cmd == SET_KEY) { 3092 ath10k_warn("cannot install key for non-existent peer %pM\n", 3093 peer_addr); 3094 ret = -EOPNOTSUPP; 3095 goto exit; 3096 } else { 3097 /* if the peer doesn't exist there is no key to disable 3098 * anymore */ 3099 goto exit; 3100 } 3101 } 3102 3103 if (is_wep) { 3104 if (cmd == SET_KEY) 3105 arvif->wep_keys[key->keyidx] = key; 3106 else 3107 arvif->wep_keys[key->keyidx] = NULL; 3108 3109 if (cmd == DISABLE_KEY) 3110 ath10k_clear_vdev_key(arvif, key); 3111 } 3112 3113 ret = ath10k_install_key(arvif, key, cmd, peer_addr); 3114 if (ret) { 3115 ath10k_warn("key installation failed for vdev %i peer %pM: %d\n", 3116 arvif->vdev_id, peer_addr, ret); 3117 goto exit; 3118 } 3119 3120 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key); 3121 3122 spin_lock_bh(&ar->data_lock); 3123 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr); 3124 if (peer && cmd == SET_KEY) 3125 peer->keys[key->keyidx] = key; 3126 else if (peer && cmd == DISABLE_KEY) 3127 peer->keys[key->keyidx] = NULL; 3128 else if (peer == NULL) 3129 /* impossible unless FW goes crazy */ 3130 ath10k_warn("peer %pM disappeared!\n", peer_addr); 3131 spin_unlock_bh(&ar->data_lock); 3132 3133 exit: 3134 mutex_unlock(&ar->conf_mutex); 3135 return ret; 3136 } 3137 3138 static void ath10k_sta_rc_update_wk(struct work_struct *wk) 3139 { 3140 struct ath10k *ar; 3141 struct ath10k_vif *arvif; 3142 struct ath10k_sta *arsta; 3143 struct ieee80211_sta *sta; 3144 u32 changed, bw, nss, smps; 3145 int err; 3146 3147 arsta = container_of(wk, struct ath10k_sta, update_wk); 3148 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv); 3149 arvif = arsta->arvif; 3150 ar = arvif->ar; 3151 3152 spin_lock_bh(&ar->data_lock); 3153 3154 changed = arsta->changed; 3155 arsta->changed = 0; 3156 3157 bw = arsta->bw; 3158 nss = arsta->nss; 3159 smps = arsta->smps; 3160 3161 spin_unlock_bh(&ar->data_lock); 3162 3163 mutex_lock(&ar->conf_mutex); 3164 3165 if (changed & IEEE80211_RC_BW_CHANGED) { 3166 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n", 3167 sta->addr, bw); 3168 3169 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 3170 WMI_PEER_CHAN_WIDTH, bw); 3171 if (err) 3172 ath10k_warn("failed to update STA %pM peer bw %d: %d\n", 3173 sta->addr, bw, err); 3174 } 3175 3176 if (changed & IEEE80211_RC_NSS_CHANGED) { 3177 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM nss %d\n", 3178 sta->addr, nss); 3179 3180 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 3181 WMI_PEER_NSS, nss); 3182 if (err) 3183 ath10k_warn("failed to update STA %pM nss %d: %d\n", 3184 sta->addr, nss, err); 3185 } 3186 3187 if (changed & IEEE80211_RC_SMPS_CHANGED) { 3188 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM smps %d\n", 3189 sta->addr, smps); 3190 3191 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr, 3192 WMI_PEER_SMPS_STATE, smps); 3193 if (err) 3194 ath10k_warn("failed to update STA %pM smps %d: %d\n", 3195 sta->addr, smps, err); 3196 } 3197 3198 mutex_unlock(&ar->conf_mutex); 3199 } 3200 3201 static int ath10k_sta_state(struct ieee80211_hw *hw, 3202 struct ieee80211_vif *vif, 3203 struct ieee80211_sta *sta, 3204 enum ieee80211_sta_state old_state, 3205 enum ieee80211_sta_state new_state) 3206 { 3207 struct ath10k *ar = hw->priv; 3208 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3209 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 3210 int max_num_peers; 3211 int ret = 0; 3212 3213 if (old_state == IEEE80211_STA_NOTEXIST && 3214 new_state == IEEE80211_STA_NONE) { 3215 memset(arsta, 0, sizeof(*arsta)); 3216 arsta->arvif = arvif; 3217 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk); 3218 } 3219 3220 /* cancel must be done outside the mutex to avoid deadlock */ 3221 if ((old_state == IEEE80211_STA_NONE && 3222 new_state == IEEE80211_STA_NOTEXIST)) 3223 cancel_work_sync(&arsta->update_wk); 3224 3225 mutex_lock(&ar->conf_mutex); 3226 3227 if (old_state == IEEE80211_STA_NOTEXIST && 3228 new_state == IEEE80211_STA_NONE && 3229 vif->type != NL80211_IFTYPE_STATION) { 3230 /* 3231 * New station addition. 3232 */ 3233 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) 3234 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1; 3235 else 3236 max_num_peers = TARGET_NUM_PEERS; 3237 3238 if (ar->num_peers >= max_num_peers) { 3239 ath10k_warn("Number of peers exceeded: peers number %d (max peers %d)\n", 3240 ar->num_peers, max_num_peers); 3241 ret = -ENOBUFS; 3242 goto exit; 3243 } 3244 3245 ath10k_dbg(ATH10K_DBG_MAC, 3246 "mac vdev %d peer create %pM (new sta) num_peers %d\n", 3247 arvif->vdev_id, sta->addr, ar->num_peers); 3248 3249 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr); 3250 if (ret) 3251 ath10k_warn("Failed to add peer %pM for vdev %d when adding a new sta: %i\n", 3252 sta->addr, arvif->vdev_id, ret); 3253 } else if ((old_state == IEEE80211_STA_NONE && 3254 new_state == IEEE80211_STA_NOTEXIST)) { 3255 /* 3256 * Existing station deletion. 3257 */ 3258 ath10k_dbg(ATH10K_DBG_MAC, 3259 "mac vdev %d peer delete %pM (sta gone)\n", 3260 arvif->vdev_id, sta->addr); 3261 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr); 3262 if (ret) 3263 ath10k_warn("Failed to delete peer %pM for vdev %d: %i\n", 3264 sta->addr, arvif->vdev_id, ret); 3265 3266 if (vif->type == NL80211_IFTYPE_STATION) 3267 ath10k_bss_disassoc(hw, vif); 3268 } else if (old_state == IEEE80211_STA_AUTH && 3269 new_state == IEEE80211_STA_ASSOC && 3270 (vif->type == NL80211_IFTYPE_AP || 3271 vif->type == NL80211_IFTYPE_ADHOC)) { 3272 /* 3273 * New association. 3274 */ 3275 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n", 3276 sta->addr); 3277 3278 ret = ath10k_station_assoc(ar, arvif, sta); 3279 if (ret) 3280 ath10k_warn("Failed to associate station %pM for vdev %i: %i\n", 3281 sta->addr, arvif->vdev_id, ret); 3282 } else if (old_state == IEEE80211_STA_ASSOC && 3283 new_state == IEEE80211_STA_AUTH && 3284 (vif->type == NL80211_IFTYPE_AP || 3285 vif->type == NL80211_IFTYPE_ADHOC)) { 3286 /* 3287 * Disassociation. 3288 */ 3289 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n", 3290 sta->addr); 3291 3292 ret = ath10k_station_disassoc(ar, arvif, sta); 3293 if (ret) 3294 ath10k_warn("Failed to disassociate station: %pM vdev %i ret %i\n", 3295 sta->addr, arvif->vdev_id, ret); 3296 } 3297 exit: 3298 mutex_unlock(&ar->conf_mutex); 3299 return ret; 3300 } 3301 3302 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif, 3303 u16 ac, bool enable) 3304 { 3305 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3306 u32 value = 0; 3307 int ret = 0; 3308 3309 lockdep_assert_held(&ar->conf_mutex); 3310 3311 if (arvif->vdev_type != WMI_VDEV_TYPE_STA) 3312 return 0; 3313 3314 switch (ac) { 3315 case IEEE80211_AC_VO: 3316 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN | 3317 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN; 3318 break; 3319 case IEEE80211_AC_VI: 3320 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN | 3321 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN; 3322 break; 3323 case IEEE80211_AC_BE: 3324 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN | 3325 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN; 3326 break; 3327 case IEEE80211_AC_BK: 3328 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN | 3329 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN; 3330 break; 3331 } 3332 3333 if (enable) 3334 arvif->u.sta.uapsd |= value; 3335 else 3336 arvif->u.sta.uapsd &= ~value; 3337 3338 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 3339 WMI_STA_PS_PARAM_UAPSD, 3340 arvif->u.sta.uapsd); 3341 if (ret) { 3342 ath10k_warn("could not set uapsd params %d\n", ret); 3343 goto exit; 3344 } 3345 3346 if (arvif->u.sta.uapsd) 3347 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD; 3348 else 3349 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE; 3350 3351 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, 3352 WMI_STA_PS_PARAM_RX_WAKE_POLICY, 3353 value); 3354 if (ret) 3355 ath10k_warn("could not set rx wake param %d\n", ret); 3356 3357 exit: 3358 return ret; 3359 } 3360 3361 static int ath10k_conf_tx(struct ieee80211_hw *hw, 3362 struct ieee80211_vif *vif, u16 ac, 3363 const struct ieee80211_tx_queue_params *params) 3364 { 3365 struct ath10k *ar = hw->priv; 3366 struct wmi_wmm_params_arg *p = NULL; 3367 int ret; 3368 3369 mutex_lock(&ar->conf_mutex); 3370 3371 switch (ac) { 3372 case IEEE80211_AC_VO: 3373 p = &ar->wmm_params.ac_vo; 3374 break; 3375 case IEEE80211_AC_VI: 3376 p = &ar->wmm_params.ac_vi; 3377 break; 3378 case IEEE80211_AC_BE: 3379 p = &ar->wmm_params.ac_be; 3380 break; 3381 case IEEE80211_AC_BK: 3382 p = &ar->wmm_params.ac_bk; 3383 break; 3384 } 3385 3386 if (WARN_ON(!p)) { 3387 ret = -EINVAL; 3388 goto exit; 3389 } 3390 3391 p->cwmin = params->cw_min; 3392 p->cwmax = params->cw_max; 3393 p->aifs = params->aifs; 3394 3395 /* 3396 * The channel time duration programmed in the HW is in absolute 3397 * microseconds, while mac80211 gives the txop in units of 3398 * 32 microseconds. 3399 */ 3400 p->txop = params->txop * 32; 3401 3402 /* FIXME: FW accepts wmm params per hw, not per vif */ 3403 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params); 3404 if (ret) { 3405 ath10k_warn("could not set wmm params %d\n", ret); 3406 goto exit; 3407 } 3408 3409 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd); 3410 if (ret) 3411 ath10k_warn("could not set sta uapsd %d\n", ret); 3412 3413 exit: 3414 mutex_unlock(&ar->conf_mutex); 3415 return ret; 3416 } 3417 3418 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ) 3419 3420 static int ath10k_remain_on_channel(struct ieee80211_hw *hw, 3421 struct ieee80211_vif *vif, 3422 struct ieee80211_channel *chan, 3423 int duration, 3424 enum ieee80211_roc_type type) 3425 { 3426 struct ath10k *ar = hw->priv; 3427 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 3428 struct wmi_start_scan_arg arg; 3429 int ret; 3430 3431 mutex_lock(&ar->conf_mutex); 3432 3433 spin_lock_bh(&ar->data_lock); 3434 if (ar->scan.in_progress) { 3435 spin_unlock_bh(&ar->data_lock); 3436 ret = -EBUSY; 3437 goto exit; 3438 } 3439 3440 reinit_completion(&ar->scan.started); 3441 reinit_completion(&ar->scan.completed); 3442 reinit_completion(&ar->scan.on_channel); 3443 ar->scan.in_progress = true; 3444 ar->scan.aborting = false; 3445 ar->scan.is_roc = true; 3446 ar->scan.vdev_id = arvif->vdev_id; 3447 ar->scan.roc_freq = chan->center_freq; 3448 spin_unlock_bh(&ar->data_lock); 3449 3450 memset(&arg, 0, sizeof(arg)); 3451 ath10k_wmi_start_scan_init(ar, &arg); 3452 arg.vdev_id = arvif->vdev_id; 3453 arg.scan_id = ATH10K_SCAN_ID; 3454 arg.n_channels = 1; 3455 arg.channels[0] = chan->center_freq; 3456 arg.dwell_time_active = duration; 3457 arg.dwell_time_passive = duration; 3458 arg.max_scan_time = 2 * duration; 3459 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE; 3460 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ; 3461 3462 ret = ath10k_start_scan(ar, &arg); 3463 if (ret) { 3464 ath10k_warn("could not start roc scan (%d)\n", ret); 3465 spin_lock_bh(&ar->data_lock); 3466 ar->scan.in_progress = false; 3467 spin_unlock_bh(&ar->data_lock); 3468 goto exit; 3469 } 3470 3471 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ); 3472 if (ret == 0) { 3473 ath10k_warn("could not switch to channel for roc scan\n"); 3474 ath10k_abort_scan(ar); 3475 ret = -ETIMEDOUT; 3476 goto exit; 3477 } 3478 3479 ret = 0; 3480 exit: 3481 mutex_unlock(&ar->conf_mutex); 3482 return ret; 3483 } 3484 3485 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw) 3486 { 3487 struct ath10k *ar = hw->priv; 3488 3489 mutex_lock(&ar->conf_mutex); 3490 ath10k_abort_scan(ar); 3491 mutex_unlock(&ar->conf_mutex); 3492 3493 return 0; 3494 } 3495 3496 /* 3497 * Both RTS and Fragmentation threshold are interface-specific 3498 * in ath10k, but device-specific in mac80211. 3499 */ 3500 3501 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 3502 { 3503 struct ath10k *ar = hw->priv; 3504 struct ath10k_vif *arvif; 3505 int ret = 0; 3506 3507 mutex_lock(&ar->conf_mutex); 3508 list_for_each_entry(arvif, &ar->arvifs, list) { 3509 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n", 3510 arvif->vdev_id, value); 3511 3512 ret = ath10k_mac_set_rts(arvif, value); 3513 if (ret) { 3514 ath10k_warn("could not set rts threshold for vdev %d (%d)\n", 3515 arvif->vdev_id, ret); 3516 break; 3517 } 3518 } 3519 mutex_unlock(&ar->conf_mutex); 3520 3521 return ret; 3522 } 3523 3524 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value) 3525 { 3526 struct ath10k *ar = hw->priv; 3527 struct ath10k_vif *arvif; 3528 int ret = 0; 3529 3530 mutex_lock(&ar->conf_mutex); 3531 list_for_each_entry(arvif, &ar->arvifs, list) { 3532 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n", 3533 arvif->vdev_id, value); 3534 3535 ret = ath10k_mac_set_rts(arvif, value); 3536 if (ret) { 3537 ath10k_warn("could not set fragmentation threshold for vdev %d (%d)\n", 3538 arvif->vdev_id, ret); 3539 break; 3540 } 3541 } 3542 mutex_unlock(&ar->conf_mutex); 3543 3544 return ret; 3545 } 3546 3547 static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop) 3548 { 3549 struct ath10k *ar = hw->priv; 3550 bool skip; 3551 int ret; 3552 3553 /* mac80211 doesn't care if we really xmit queued frames or not 3554 * we'll collect those frames either way if we stop/delete vdevs */ 3555 if (drop) 3556 return; 3557 3558 mutex_lock(&ar->conf_mutex); 3559 3560 if (ar->state == ATH10K_STATE_WEDGED) 3561 goto skip; 3562 3563 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({ 3564 bool empty; 3565 3566 spin_lock_bh(&ar->htt.tx_lock); 3567 empty = (ar->htt.num_pending_tx == 0); 3568 spin_unlock_bh(&ar->htt.tx_lock); 3569 3570 skip = (ar->state == ATH10K_STATE_WEDGED); 3571 3572 (empty || skip); 3573 }), ATH10K_FLUSH_TIMEOUT_HZ); 3574 3575 if (ret <= 0 || skip) 3576 ath10k_warn("tx not flushed (skip %i ar-state %i): %i\n", 3577 skip, ar->state, ret); 3578 3579 skip: 3580 mutex_unlock(&ar->conf_mutex); 3581 } 3582 3583 /* TODO: Implement this function properly 3584 * For now it is needed to reply to Probe Requests in IBSS mode. 3585 * Propably we need this information from FW. 3586 */ 3587 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw) 3588 { 3589 return 1; 3590 } 3591 3592 #ifdef CONFIG_PM 3593 static int ath10k_suspend(struct ieee80211_hw *hw, 3594 struct cfg80211_wowlan *wowlan) 3595 { 3596 struct ath10k *ar = hw->priv; 3597 int ret; 3598 3599 mutex_lock(&ar->conf_mutex); 3600 3601 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND); 3602 if (ret) { 3603 if (ret == -ETIMEDOUT) 3604 goto resume; 3605 ret = 1; 3606 goto exit; 3607 } 3608 3609 ret = ath10k_hif_suspend(ar); 3610 if (ret) { 3611 ath10k_warn("could not suspend hif (%d)\n", ret); 3612 goto resume; 3613 } 3614 3615 ret = 0; 3616 goto exit; 3617 resume: 3618 ret = ath10k_wmi_pdev_resume_target(ar); 3619 if (ret) 3620 ath10k_warn("could not resume target (%d)\n", ret); 3621 3622 ret = 1; 3623 exit: 3624 mutex_unlock(&ar->conf_mutex); 3625 return ret; 3626 } 3627 3628 static int ath10k_resume(struct ieee80211_hw *hw) 3629 { 3630 struct ath10k *ar = hw->priv; 3631 int ret; 3632 3633 mutex_lock(&ar->conf_mutex); 3634 3635 ret = ath10k_hif_resume(ar); 3636 if (ret) { 3637 ath10k_warn("could not resume hif (%d)\n", ret); 3638 ret = 1; 3639 goto exit; 3640 } 3641 3642 ret = ath10k_wmi_pdev_resume_target(ar); 3643 if (ret) { 3644 ath10k_warn("could not resume target (%d)\n", ret); 3645 ret = 1; 3646 goto exit; 3647 } 3648 3649 ret = 0; 3650 exit: 3651 mutex_unlock(&ar->conf_mutex); 3652 return ret; 3653 } 3654 #endif 3655 3656 static void ath10k_restart_complete(struct ieee80211_hw *hw) 3657 { 3658 struct ath10k *ar = hw->priv; 3659 3660 mutex_lock(&ar->conf_mutex); 3661 3662 /* If device failed to restart it will be in a different state, e.g. 3663 * ATH10K_STATE_WEDGED */ 3664 if (ar->state == ATH10K_STATE_RESTARTED) { 3665 ath10k_info("device successfully recovered\n"); 3666 ar->state = ATH10K_STATE_ON; 3667 } 3668 3669 mutex_unlock(&ar->conf_mutex); 3670 } 3671 3672 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx, 3673 struct survey_info *survey) 3674 { 3675 struct ath10k *ar = hw->priv; 3676 struct ieee80211_supported_band *sband; 3677 struct survey_info *ar_survey = &ar->survey[idx]; 3678 int ret = 0; 3679 3680 mutex_lock(&ar->conf_mutex); 3681 3682 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ]; 3683 if (sband && idx >= sband->n_channels) { 3684 idx -= sband->n_channels; 3685 sband = NULL; 3686 } 3687 3688 if (!sband) 3689 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ]; 3690 3691 if (!sband || idx >= sband->n_channels) { 3692 ret = -ENOENT; 3693 goto exit; 3694 } 3695 3696 spin_lock_bh(&ar->data_lock); 3697 memcpy(survey, ar_survey, sizeof(*survey)); 3698 spin_unlock_bh(&ar->data_lock); 3699 3700 survey->channel = &sband->channels[idx]; 3701 3702 exit: 3703 mutex_unlock(&ar->conf_mutex); 3704 return ret; 3705 } 3706 3707 /* Helper table for legacy fixed_rate/bitrate_mask */ 3708 static const u8 cck_ofdm_rate[] = { 3709 /* CCK */ 3710 3, /* 1Mbps */ 3711 2, /* 2Mbps */ 3712 1, /* 5.5Mbps */ 3713 0, /* 11Mbps */ 3714 /* OFDM */ 3715 3, /* 6Mbps */ 3716 7, /* 9Mbps */ 3717 2, /* 12Mbps */ 3718 6, /* 18Mbps */ 3719 1, /* 24Mbps */ 3720 5, /* 36Mbps */ 3721 0, /* 48Mbps */ 3722 4, /* 54Mbps */ 3723 }; 3724 3725 /* Check if only one bit set */ 3726 static int ath10k_check_single_mask(u32 mask) 3727 { 3728 int bit; 3729 3730 bit = ffs(mask); 3731 if (!bit) 3732 return 0; 3733 3734 mask &= ~BIT(bit - 1); 3735 if (mask) 3736 return 2; 3737 3738 return 1; 3739 } 3740 3741 static bool 3742 ath10k_default_bitrate_mask(struct ath10k *ar, 3743 enum ieee80211_band band, 3744 const struct cfg80211_bitrate_mask *mask) 3745 { 3746 u32 legacy = 0x00ff; 3747 u8 ht = 0xff, i; 3748 u16 vht = 0x3ff; 3749 3750 switch (band) { 3751 case IEEE80211_BAND_2GHZ: 3752 legacy = 0x00fff; 3753 vht = 0; 3754 break; 3755 case IEEE80211_BAND_5GHZ: 3756 break; 3757 default: 3758 return false; 3759 } 3760 3761 if (mask->control[band].legacy != legacy) 3762 return false; 3763 3764 for (i = 0; i < ar->num_rf_chains; i++) 3765 if (mask->control[band].ht_mcs[i] != ht) 3766 return false; 3767 3768 for (i = 0; i < ar->num_rf_chains; i++) 3769 if (mask->control[band].vht_mcs[i] != vht) 3770 return false; 3771 3772 return true; 3773 } 3774 3775 static bool 3776 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask, 3777 enum ieee80211_band band, 3778 u8 *fixed_nss) 3779 { 3780 int ht_nss = 0, vht_nss = 0, i; 3781 3782 /* check legacy */ 3783 if (ath10k_check_single_mask(mask->control[band].legacy)) 3784 return false; 3785 3786 /* check HT */ 3787 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) { 3788 if (mask->control[band].ht_mcs[i] == 0xff) 3789 continue; 3790 else if (mask->control[band].ht_mcs[i] == 0x00) 3791 break; 3792 else 3793 return false; 3794 } 3795 3796 ht_nss = i; 3797 3798 /* check VHT */ 3799 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 3800 if (mask->control[band].vht_mcs[i] == 0x03ff) 3801 continue; 3802 else if (mask->control[band].vht_mcs[i] == 0x0000) 3803 break; 3804 else 3805 return false; 3806 } 3807 3808 vht_nss = i; 3809 3810 if (ht_nss > 0 && vht_nss > 0) 3811 return false; 3812 3813 if (ht_nss) 3814 *fixed_nss = ht_nss; 3815 else if (vht_nss) 3816 *fixed_nss = vht_nss; 3817 else 3818 return false; 3819 3820 return true; 3821 } 3822 3823 static bool 3824 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask, 3825 enum ieee80211_band band, 3826 enum wmi_rate_preamble *preamble) 3827 { 3828 int legacy = 0, ht = 0, vht = 0, i; 3829 3830 *preamble = WMI_RATE_PREAMBLE_OFDM; 3831 3832 /* check legacy */ 3833 legacy = ath10k_check_single_mask(mask->control[band].legacy); 3834 if (legacy > 1) 3835 return false; 3836 3837 /* check HT */ 3838 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) 3839 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]); 3840 if (ht > 1) 3841 return false; 3842 3843 /* check VHT */ 3844 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) 3845 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]); 3846 if (vht > 1) 3847 return false; 3848 3849 /* Currently we support only one fixed_rate */ 3850 if ((legacy + ht + vht) != 1) 3851 return false; 3852 3853 if (ht) 3854 *preamble = WMI_RATE_PREAMBLE_HT; 3855 else if (vht) 3856 *preamble = WMI_RATE_PREAMBLE_VHT; 3857 3858 return true; 3859 } 3860 3861 static bool 3862 ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask, 3863 enum ieee80211_band band, 3864 u8 *fixed_rate, 3865 u8 *fixed_nss) 3866 { 3867 u8 rate = 0, pream = 0, nss = 0, i; 3868 enum wmi_rate_preamble preamble; 3869 3870 /* Check if single rate correct */ 3871 if (!ath10k_bitrate_mask_correct(mask, band, &preamble)) 3872 return false; 3873 3874 pream = preamble; 3875 3876 switch (preamble) { 3877 case WMI_RATE_PREAMBLE_CCK: 3878 case WMI_RATE_PREAMBLE_OFDM: 3879 i = ffs(mask->control[band].legacy) - 1; 3880 3881 if (band == IEEE80211_BAND_2GHZ && i < 4) 3882 pream = WMI_RATE_PREAMBLE_CCK; 3883 3884 if (band == IEEE80211_BAND_5GHZ) 3885 i += 4; 3886 3887 if (i >= ARRAY_SIZE(cck_ofdm_rate)) 3888 return false; 3889 3890 rate = cck_ofdm_rate[i]; 3891 break; 3892 case WMI_RATE_PREAMBLE_HT: 3893 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) 3894 if (mask->control[band].ht_mcs[i]) 3895 break; 3896 3897 if (i == IEEE80211_HT_MCS_MASK_LEN) 3898 return false; 3899 3900 rate = ffs(mask->control[band].ht_mcs[i]) - 1; 3901 nss = i; 3902 break; 3903 case WMI_RATE_PREAMBLE_VHT: 3904 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) 3905 if (mask->control[band].vht_mcs[i]) 3906 break; 3907 3908 if (i == NL80211_VHT_NSS_MAX) 3909 return false; 3910 3911 rate = ffs(mask->control[band].vht_mcs[i]) - 1; 3912 nss = i; 3913 break; 3914 } 3915 3916 *fixed_nss = nss + 1; 3917 nss <<= 4; 3918 pream <<= 6; 3919 3920 ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n", 3921 pream, nss, rate); 3922 3923 *fixed_rate = pream | nss | rate; 3924 3925 return true; 3926 } 3927 3928 static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask, 3929 enum ieee80211_band band, 3930 u8 *fixed_rate, 3931 u8 *fixed_nss) 3932 { 3933 /* First check full NSS mask, if we can simply limit NSS */ 3934 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss)) 3935 return true; 3936 3937 /* Next Check single rate is set */ 3938 return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss); 3939 } 3940 3941 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif, 3942 u8 fixed_rate, 3943 u8 fixed_nss, 3944 u8 force_sgi) 3945 { 3946 struct ath10k *ar = arvif->ar; 3947 u32 vdev_param; 3948 int ret = 0; 3949 3950 mutex_lock(&ar->conf_mutex); 3951 3952 if (arvif->fixed_rate == fixed_rate && 3953 arvif->fixed_nss == fixed_nss && 3954 arvif->force_sgi == force_sgi) 3955 goto exit; 3956 3957 if (fixed_rate == WMI_FIXED_RATE_NONE) 3958 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n"); 3959 3960 if (force_sgi) 3961 ath10k_dbg(ATH10K_DBG_MAC, "mac force sgi\n"); 3962 3963 vdev_param = ar->wmi.vdev_param->fixed_rate; 3964 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 3965 vdev_param, fixed_rate); 3966 if (ret) { 3967 ath10k_warn("Could not set fixed_rate param 0x%02x: %d\n", 3968 fixed_rate, ret); 3969 ret = -EINVAL; 3970 goto exit; 3971 } 3972 3973 arvif->fixed_rate = fixed_rate; 3974 3975 vdev_param = ar->wmi.vdev_param->nss; 3976 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, 3977 vdev_param, fixed_nss); 3978 3979 if (ret) { 3980 ath10k_warn("Could not set fixed_nss param %d: %d\n", 3981 fixed_nss, ret); 3982 ret = -EINVAL; 3983 goto exit; 3984 } 3985 3986 arvif->fixed_nss = fixed_nss; 3987 3988 vdev_param = ar->wmi.vdev_param->sgi; 3989 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, 3990 force_sgi); 3991 3992 if (ret) { 3993 ath10k_warn("Could not set sgi param %d: %d\n", 3994 force_sgi, ret); 3995 ret = -EINVAL; 3996 goto exit; 3997 } 3998 3999 arvif->force_sgi = force_sgi; 4000 4001 exit: 4002 mutex_unlock(&ar->conf_mutex); 4003 return ret; 4004 } 4005 4006 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw, 4007 struct ieee80211_vif *vif, 4008 const struct cfg80211_bitrate_mask *mask) 4009 { 4010 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4011 struct ath10k *ar = arvif->ar; 4012 enum ieee80211_band band = ar->hw->conf.chandef.chan->band; 4013 u8 fixed_rate = WMI_FIXED_RATE_NONE; 4014 u8 fixed_nss = ar->num_rf_chains; 4015 u8 force_sgi; 4016 4017 force_sgi = mask->control[band].gi; 4018 if (force_sgi == NL80211_TXRATE_FORCE_LGI) 4019 return -EINVAL; 4020 4021 if (!ath10k_default_bitrate_mask(ar, band, mask)) { 4022 if (!ath10k_get_fixed_rate_nss(mask, band, 4023 &fixed_rate, 4024 &fixed_nss)) 4025 return -EINVAL; 4026 } 4027 4028 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) { 4029 ath10k_warn("Could not force SGI usage for default rate settings\n"); 4030 return -EINVAL; 4031 } 4032 4033 return ath10k_set_fixed_rate_param(arvif, fixed_rate, 4034 fixed_nss, force_sgi); 4035 } 4036 4037 static void ath10k_channel_switch_beacon(struct ieee80211_hw *hw, 4038 struct ieee80211_vif *vif, 4039 struct cfg80211_chan_def *chandef) 4040 { 4041 /* there's no need to do anything here. vif->csa_active is enough */ 4042 return; 4043 } 4044 4045 static void ath10k_sta_rc_update(struct ieee80211_hw *hw, 4046 struct ieee80211_vif *vif, 4047 struct ieee80211_sta *sta, 4048 u32 changed) 4049 { 4050 struct ath10k *ar = hw->priv; 4051 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv; 4052 u32 bw, smps; 4053 4054 spin_lock_bh(&ar->data_lock); 4055 4056 ath10k_dbg(ATH10K_DBG_MAC, 4057 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n", 4058 sta->addr, changed, sta->bandwidth, sta->rx_nss, 4059 sta->smps_mode); 4060 4061 if (changed & IEEE80211_RC_BW_CHANGED) { 4062 bw = WMI_PEER_CHWIDTH_20MHZ; 4063 4064 switch (sta->bandwidth) { 4065 case IEEE80211_STA_RX_BW_20: 4066 bw = WMI_PEER_CHWIDTH_20MHZ; 4067 break; 4068 case IEEE80211_STA_RX_BW_40: 4069 bw = WMI_PEER_CHWIDTH_40MHZ; 4070 break; 4071 case IEEE80211_STA_RX_BW_80: 4072 bw = WMI_PEER_CHWIDTH_80MHZ; 4073 break; 4074 case IEEE80211_STA_RX_BW_160: 4075 ath10k_warn("mac sta rc update for %pM: invalid bw %d\n", 4076 sta->addr, sta->bandwidth); 4077 bw = WMI_PEER_CHWIDTH_20MHZ; 4078 break; 4079 } 4080 4081 arsta->bw = bw; 4082 } 4083 4084 if (changed & IEEE80211_RC_NSS_CHANGED) 4085 arsta->nss = sta->rx_nss; 4086 4087 if (changed & IEEE80211_RC_SMPS_CHANGED) { 4088 smps = WMI_PEER_SMPS_PS_NONE; 4089 4090 switch (sta->smps_mode) { 4091 case IEEE80211_SMPS_AUTOMATIC: 4092 case IEEE80211_SMPS_OFF: 4093 smps = WMI_PEER_SMPS_PS_NONE; 4094 break; 4095 case IEEE80211_SMPS_STATIC: 4096 smps = WMI_PEER_SMPS_STATIC; 4097 break; 4098 case IEEE80211_SMPS_DYNAMIC: 4099 smps = WMI_PEER_SMPS_DYNAMIC; 4100 break; 4101 case IEEE80211_SMPS_NUM_MODES: 4102 ath10k_warn("mac sta rc update for %pM: invalid smps: %d\n", 4103 sta->addr, sta->smps_mode); 4104 smps = WMI_PEER_SMPS_PS_NONE; 4105 break; 4106 } 4107 4108 arsta->smps = smps; 4109 } 4110 4111 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) { 4112 /* FIXME: Not implemented. Probably the only way to do it would 4113 * be to re-assoc the peer. */ 4114 changed &= ~IEEE80211_RC_SUPP_RATES_CHANGED; 4115 ath10k_dbg(ATH10K_DBG_MAC, 4116 "mac sta rc update for %pM: changing supported rates not implemented\n", 4117 sta->addr); 4118 } 4119 4120 arsta->changed |= changed; 4121 4122 spin_unlock_bh(&ar->data_lock); 4123 4124 ieee80211_queue_work(hw, &arsta->update_wk); 4125 } 4126 4127 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 4128 { 4129 /* 4130 * FIXME: Return 0 for time being. Need to figure out whether FW 4131 * has the API to fetch 64-bit local TSF 4132 */ 4133 4134 return 0; 4135 } 4136 4137 static const struct ieee80211_ops ath10k_ops = { 4138 .tx = ath10k_tx, 4139 .start = ath10k_start, 4140 .stop = ath10k_stop, 4141 .config = ath10k_config, 4142 .add_interface = ath10k_add_interface, 4143 .remove_interface = ath10k_remove_interface, 4144 .configure_filter = ath10k_configure_filter, 4145 .bss_info_changed = ath10k_bss_info_changed, 4146 .hw_scan = ath10k_hw_scan, 4147 .cancel_hw_scan = ath10k_cancel_hw_scan, 4148 .set_key = ath10k_set_key, 4149 .sta_state = ath10k_sta_state, 4150 .conf_tx = ath10k_conf_tx, 4151 .remain_on_channel = ath10k_remain_on_channel, 4152 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel, 4153 .set_rts_threshold = ath10k_set_rts_threshold, 4154 .set_frag_threshold = ath10k_set_frag_threshold, 4155 .flush = ath10k_flush, 4156 .tx_last_beacon = ath10k_tx_last_beacon, 4157 .restart_complete = ath10k_restart_complete, 4158 .get_survey = ath10k_get_survey, 4159 .set_bitrate_mask = ath10k_set_bitrate_mask, 4160 .channel_switch_beacon = ath10k_channel_switch_beacon, 4161 .sta_rc_update = ath10k_sta_rc_update, 4162 .get_tsf = ath10k_get_tsf, 4163 #ifdef CONFIG_PM 4164 .suspend = ath10k_suspend, 4165 .resume = ath10k_resume, 4166 #endif 4167 }; 4168 4169 #define RATETAB_ENT(_rate, _rateid, _flags) { \ 4170 .bitrate = (_rate), \ 4171 .flags = (_flags), \ 4172 .hw_value = (_rateid), \ 4173 } 4174 4175 #define CHAN2G(_channel, _freq, _flags) { \ 4176 .band = IEEE80211_BAND_2GHZ, \ 4177 .hw_value = (_channel), \ 4178 .center_freq = (_freq), \ 4179 .flags = (_flags), \ 4180 .max_antenna_gain = 0, \ 4181 .max_power = 30, \ 4182 } 4183 4184 #define CHAN5G(_channel, _freq, _flags) { \ 4185 .band = IEEE80211_BAND_5GHZ, \ 4186 .hw_value = (_channel), \ 4187 .center_freq = (_freq), \ 4188 .flags = (_flags), \ 4189 .max_antenna_gain = 0, \ 4190 .max_power = 30, \ 4191 } 4192 4193 static const struct ieee80211_channel ath10k_2ghz_channels[] = { 4194 CHAN2G(1, 2412, 0), 4195 CHAN2G(2, 2417, 0), 4196 CHAN2G(3, 2422, 0), 4197 CHAN2G(4, 2427, 0), 4198 CHAN2G(5, 2432, 0), 4199 CHAN2G(6, 2437, 0), 4200 CHAN2G(7, 2442, 0), 4201 CHAN2G(8, 2447, 0), 4202 CHAN2G(9, 2452, 0), 4203 CHAN2G(10, 2457, 0), 4204 CHAN2G(11, 2462, 0), 4205 CHAN2G(12, 2467, 0), 4206 CHAN2G(13, 2472, 0), 4207 CHAN2G(14, 2484, 0), 4208 }; 4209 4210 static const struct ieee80211_channel ath10k_5ghz_channels[] = { 4211 CHAN5G(36, 5180, 0), 4212 CHAN5G(40, 5200, 0), 4213 CHAN5G(44, 5220, 0), 4214 CHAN5G(48, 5240, 0), 4215 CHAN5G(52, 5260, 0), 4216 CHAN5G(56, 5280, 0), 4217 CHAN5G(60, 5300, 0), 4218 CHAN5G(64, 5320, 0), 4219 CHAN5G(100, 5500, 0), 4220 CHAN5G(104, 5520, 0), 4221 CHAN5G(108, 5540, 0), 4222 CHAN5G(112, 5560, 0), 4223 CHAN5G(116, 5580, 0), 4224 CHAN5G(120, 5600, 0), 4225 CHAN5G(124, 5620, 0), 4226 CHAN5G(128, 5640, 0), 4227 CHAN5G(132, 5660, 0), 4228 CHAN5G(136, 5680, 0), 4229 CHAN5G(140, 5700, 0), 4230 CHAN5G(149, 5745, 0), 4231 CHAN5G(153, 5765, 0), 4232 CHAN5G(157, 5785, 0), 4233 CHAN5G(161, 5805, 0), 4234 CHAN5G(165, 5825, 0), 4235 }; 4236 4237 static struct ieee80211_rate ath10k_rates[] = { 4238 /* CCK */ 4239 RATETAB_ENT(10, 0x82, 0), 4240 RATETAB_ENT(20, 0x84, 0), 4241 RATETAB_ENT(55, 0x8b, 0), 4242 RATETAB_ENT(110, 0x96, 0), 4243 /* OFDM */ 4244 RATETAB_ENT(60, 0x0c, 0), 4245 RATETAB_ENT(90, 0x12, 0), 4246 RATETAB_ENT(120, 0x18, 0), 4247 RATETAB_ENT(180, 0x24, 0), 4248 RATETAB_ENT(240, 0x30, 0), 4249 RATETAB_ENT(360, 0x48, 0), 4250 RATETAB_ENT(480, 0x60, 0), 4251 RATETAB_ENT(540, 0x6c, 0), 4252 }; 4253 4254 #define ath10k_a_rates (ath10k_rates + 4) 4255 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4) 4256 #define ath10k_g_rates (ath10k_rates + 0) 4257 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates)) 4258 4259 struct ath10k *ath10k_mac_create(void) 4260 { 4261 struct ieee80211_hw *hw; 4262 struct ath10k *ar; 4263 4264 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops); 4265 if (!hw) 4266 return NULL; 4267 4268 ar = hw->priv; 4269 ar->hw = hw; 4270 4271 return ar; 4272 } 4273 4274 void ath10k_mac_destroy(struct ath10k *ar) 4275 { 4276 ieee80211_free_hw(ar->hw); 4277 } 4278 4279 static const struct ieee80211_iface_limit ath10k_if_limits[] = { 4280 { 4281 .max = 8, 4282 .types = BIT(NL80211_IFTYPE_STATION) 4283 | BIT(NL80211_IFTYPE_P2P_CLIENT) 4284 }, 4285 { 4286 .max = 3, 4287 .types = BIT(NL80211_IFTYPE_P2P_GO) 4288 }, 4289 { 4290 .max = 7, 4291 .types = BIT(NL80211_IFTYPE_AP) 4292 }, 4293 }; 4294 4295 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = { 4296 { 4297 .max = 8, 4298 .types = BIT(NL80211_IFTYPE_AP) 4299 }, 4300 }; 4301 4302 static const struct ieee80211_iface_combination ath10k_if_comb[] = { 4303 { 4304 .limits = ath10k_if_limits, 4305 .n_limits = ARRAY_SIZE(ath10k_if_limits), 4306 .max_interfaces = 8, 4307 .num_different_channels = 1, 4308 .beacon_int_infra_match = true, 4309 }, 4310 }; 4311 4312 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = { 4313 { 4314 .limits = ath10k_10x_if_limits, 4315 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits), 4316 .max_interfaces = 8, 4317 .num_different_channels = 1, 4318 .beacon_int_infra_match = true, 4319 #ifdef CONFIG_ATH10K_DFS_CERTIFIED 4320 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) | 4321 BIT(NL80211_CHAN_WIDTH_20) | 4322 BIT(NL80211_CHAN_WIDTH_40) | 4323 BIT(NL80211_CHAN_WIDTH_80), 4324 #endif 4325 }, 4326 }; 4327 4328 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar) 4329 { 4330 struct ieee80211_sta_vht_cap vht_cap = {0}; 4331 u16 mcs_map; 4332 int i; 4333 4334 vht_cap.vht_supported = 1; 4335 vht_cap.cap = ar->vht_cap_info; 4336 4337 mcs_map = 0; 4338 for (i = 0; i < 8; i++) { 4339 if (i < ar->num_rf_chains) 4340 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2); 4341 else 4342 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2); 4343 } 4344 4345 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map); 4346 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map); 4347 4348 return vht_cap; 4349 } 4350 4351 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar) 4352 { 4353 int i; 4354 struct ieee80211_sta_ht_cap ht_cap = {0}; 4355 4356 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED)) 4357 return ht_cap; 4358 4359 ht_cap.ht_supported = 1; 4360 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 4361 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8; 4362 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 4363 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 4364 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT; 4365 4366 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI) 4367 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 4368 4369 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI) 4370 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 4371 4372 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) { 4373 u32 smps; 4374 4375 smps = WLAN_HT_CAP_SM_PS_DYNAMIC; 4376 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT; 4377 4378 ht_cap.cap |= smps; 4379 } 4380 4381 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC) 4382 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 4383 4384 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) { 4385 u32 stbc; 4386 4387 stbc = ar->ht_cap_info; 4388 stbc &= WMI_HT_CAP_RX_STBC; 4389 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT; 4390 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT; 4391 stbc &= IEEE80211_HT_CAP_RX_STBC; 4392 4393 ht_cap.cap |= stbc; 4394 } 4395 4396 if (ar->ht_cap_info & WMI_HT_CAP_LDPC) 4397 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING; 4398 4399 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT) 4400 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT; 4401 4402 /* max AMSDU is implicitly taken from vht_cap_info */ 4403 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK) 4404 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 4405 4406 for (i = 0; i < ar->num_rf_chains; i++) 4407 ht_cap.mcs.rx_mask[i] = 0xFF; 4408 4409 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED; 4410 4411 return ht_cap; 4412 } 4413 4414 4415 static void ath10k_get_arvif_iter(void *data, u8 *mac, 4416 struct ieee80211_vif *vif) 4417 { 4418 struct ath10k_vif_iter *arvif_iter = data; 4419 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif); 4420 4421 if (arvif->vdev_id == arvif_iter->vdev_id) 4422 arvif_iter->arvif = arvif; 4423 } 4424 4425 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id) 4426 { 4427 struct ath10k_vif_iter arvif_iter; 4428 u32 flags; 4429 4430 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter)); 4431 arvif_iter.vdev_id = vdev_id; 4432 4433 flags = IEEE80211_IFACE_ITER_RESUME_ALL; 4434 ieee80211_iterate_active_interfaces_atomic(ar->hw, 4435 flags, 4436 ath10k_get_arvif_iter, 4437 &arvif_iter); 4438 if (!arvif_iter.arvif) { 4439 ath10k_warn("No VIF found for vdev %d\n", vdev_id); 4440 return NULL; 4441 } 4442 4443 return arvif_iter.arvif; 4444 } 4445 4446 int ath10k_mac_register(struct ath10k *ar) 4447 { 4448 struct ieee80211_supported_band *band; 4449 struct ieee80211_sta_vht_cap vht_cap; 4450 struct ieee80211_sta_ht_cap ht_cap; 4451 void *channels; 4452 int ret; 4453 4454 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr); 4455 4456 SET_IEEE80211_DEV(ar->hw, ar->dev); 4457 4458 ht_cap = ath10k_get_ht_cap(ar); 4459 vht_cap = ath10k_create_vht_cap(ar); 4460 4461 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) { 4462 channels = kmemdup(ath10k_2ghz_channels, 4463 sizeof(ath10k_2ghz_channels), 4464 GFP_KERNEL); 4465 if (!channels) { 4466 ret = -ENOMEM; 4467 goto err_free; 4468 } 4469 4470 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ]; 4471 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels); 4472 band->channels = channels; 4473 band->n_bitrates = ath10k_g_rates_size; 4474 band->bitrates = ath10k_g_rates; 4475 band->ht_cap = ht_cap; 4476 4477 /* vht is not supported in 2.4 GHz */ 4478 4479 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band; 4480 } 4481 4482 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) { 4483 channels = kmemdup(ath10k_5ghz_channels, 4484 sizeof(ath10k_5ghz_channels), 4485 GFP_KERNEL); 4486 if (!channels) { 4487 ret = -ENOMEM; 4488 goto err_free; 4489 } 4490 4491 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ]; 4492 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels); 4493 band->channels = channels; 4494 band->n_bitrates = ath10k_a_rates_size; 4495 band->bitrates = ath10k_a_rates; 4496 band->ht_cap = ht_cap; 4497 band->vht_cap = vht_cap; 4498 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band; 4499 } 4500 4501 ar->hw->wiphy->interface_modes = 4502 BIT(NL80211_IFTYPE_STATION) | 4503 BIT(NL80211_IFTYPE_ADHOC) | 4504 BIT(NL80211_IFTYPE_AP); 4505 4506 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features)) 4507 ar->hw->wiphy->interface_modes |= 4508 BIT(NL80211_IFTYPE_P2P_CLIENT) | 4509 BIT(NL80211_IFTYPE_P2P_GO); 4510 4511 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM | 4512 IEEE80211_HW_SUPPORTS_PS | 4513 IEEE80211_HW_SUPPORTS_DYNAMIC_PS | 4514 IEEE80211_HW_SUPPORTS_UAPSD | 4515 IEEE80211_HW_MFP_CAPABLE | 4516 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 4517 IEEE80211_HW_HAS_RATE_CONTROL | 4518 IEEE80211_HW_SUPPORTS_STATIC_SMPS | 4519 IEEE80211_HW_WANT_MONITOR_VIF | 4520 IEEE80211_HW_AP_LINK_PS | 4521 IEEE80211_HW_SPECTRUM_MGMT; 4522 4523 /* MSDU can have HTT TX fragment pushed in front. The additional 4 4524 * bytes is used for padding/alignment if necessary. */ 4525 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4; 4526 4527 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) 4528 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS; 4529 4530 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) { 4531 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION; 4532 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW; 4533 } 4534 4535 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID; 4536 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN; 4537 4538 ar->hw->vif_data_size = sizeof(struct ath10k_vif); 4539 ar->hw->sta_data_size = sizeof(struct ath10k_sta); 4540 4541 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL; 4542 4543 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 4544 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH; 4545 ar->hw->wiphy->max_remain_on_channel_duration = 5000; 4546 4547 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; 4548 /* 4549 * on LL hardware queues are managed entirely by the FW 4550 * so we only advertise to mac we can do the queues thing 4551 */ 4552 ar->hw->queues = 4; 4553 4554 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) { 4555 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb; 4556 ar->hw->wiphy->n_iface_combinations = 4557 ARRAY_SIZE(ath10k_10x_if_comb); 4558 } else { 4559 ar->hw->wiphy->iface_combinations = ath10k_if_comb; 4560 ar->hw->wiphy->n_iface_combinations = 4561 ARRAY_SIZE(ath10k_if_comb); 4562 } 4563 4564 ar->hw->netdev_features = NETIF_F_HW_CSUM; 4565 4566 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) { 4567 /* Init ath dfs pattern detector */ 4568 ar->ath_common.debug_mask = ATH_DBG_DFS; 4569 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common, 4570 NL80211_DFS_UNSET); 4571 4572 if (!ar->dfs_detector) 4573 ath10k_warn("dfs pattern detector init failed\n"); 4574 } 4575 4576 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy, 4577 ath10k_reg_notifier); 4578 if (ret) { 4579 ath10k_err("Regulatory initialization failed: %i\n", ret); 4580 goto err_free; 4581 } 4582 4583 ret = ieee80211_register_hw(ar->hw); 4584 if (ret) { 4585 ath10k_err("ieee80211 registration failed: %d\n", ret); 4586 goto err_free; 4587 } 4588 4589 if (!ath_is_world_regd(&ar->ath_common.regulatory)) { 4590 ret = regulatory_hint(ar->hw->wiphy, 4591 ar->ath_common.regulatory.alpha2); 4592 if (ret) 4593 goto err_unregister; 4594 } 4595 4596 return 0; 4597 4598 err_unregister: 4599 ieee80211_unregister_hw(ar->hw); 4600 err_free: 4601 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 4602 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 4603 4604 return ret; 4605 } 4606 4607 void ath10k_mac_unregister(struct ath10k *ar) 4608 { 4609 ieee80211_unregister_hw(ar->hw); 4610 4611 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) 4612 ar->dfs_detector->exit(ar->dfs_detector); 4613 4614 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels); 4615 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels); 4616 4617 SET_IEEE80211_DEV(ar->hw, NULL); 4618 } 4619