mac80211.c revision 1023fdc4858b6b8cb88ff28cafd425b77555be9f
1/****************************************************************************** 2 * 3 * Copyright(c) 2003 - 2012 Intel Corporation. All rights reserved. 4 * 5 * Portions of this file are derived from the ipw3945 project, as well 6 * as portions of the ieee80211 subsystem header files. 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of version 2 of the GNU General Public License as 10 * published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but WITHOUT 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 15 * more details. 16 * 17 * You should have received a copy of the GNU General Public License along with 18 * this program; if not, write to the Free Software Foundation, Inc., 19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 20 * 21 * The full GNU General Public License is included in this distribution in the 22 * file called LICENSE. 23 * 24 * Contact Information: 25 * Intel Linux Wireless <ilw@linux.intel.com> 26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 27 * 28 *****************************************************************************/ 29#include <linux/kernel.h> 30#include <linux/module.h> 31#include <linux/init.h> 32#include <linux/slab.h> 33#include <linux/dma-mapping.h> 34#include <linux/delay.h> 35#include <linux/sched.h> 36#include <linux/skbuff.h> 37#include <linux/netdevice.h> 38#include <linux/etherdevice.h> 39#include <linux/if_arp.h> 40 41#include <net/ieee80211_radiotap.h> 42#include <net/mac80211.h> 43 44#include <asm/div64.h> 45 46#include "iwl-io.h" 47#include "iwl-trans.h" 48#include "iwl-op-mode.h" 49#include "iwl-modparams.h" 50 51#include "eeprom.h" 52#include "dev.h" 53#include "calib.h" 54#include "agn.h" 55 56/***************************************************************************** 57 * 58 * mac80211 entry point functions 59 * 60 *****************************************************************************/ 61 62static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = { 63 { 64 .max = 1, 65 .types = BIT(NL80211_IFTYPE_STATION), 66 }, 67 { 68 .max = 1, 69 .types = BIT(NL80211_IFTYPE_AP), 70 }, 71}; 72 73static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = { 74 { 75 .max = 2, 76 .types = BIT(NL80211_IFTYPE_STATION), 77 }, 78}; 79 80static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = { 81 { 82 .max = 1, 83 .types = BIT(NL80211_IFTYPE_STATION), 84 }, 85 { 86 .max = 1, 87 .types = BIT(NL80211_IFTYPE_P2P_GO) | 88 BIT(NL80211_IFTYPE_AP), 89 }, 90}; 91 92static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = { 93 { 94 .max = 2, 95 .types = BIT(NL80211_IFTYPE_STATION), 96 }, 97 { 98 .max = 1, 99 .types = BIT(NL80211_IFTYPE_P2P_CLIENT), 100 }, 101}; 102 103static const struct ieee80211_iface_combination 104iwlagn_iface_combinations_dualmode[] = { 105 { .num_different_channels = 1, 106 .max_interfaces = 2, 107 .beacon_int_infra_match = true, 108 .limits = iwlagn_sta_ap_limits, 109 .n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits), 110 }, 111 { .num_different_channels = 1, 112 .max_interfaces = 2, 113 .limits = iwlagn_2sta_limits, 114 .n_limits = ARRAY_SIZE(iwlagn_2sta_limits), 115 }, 116}; 117 118static const struct ieee80211_iface_combination 119iwlagn_iface_combinations_p2p[] = { 120 { .num_different_channels = 1, 121 .max_interfaces = 2, 122 .beacon_int_infra_match = true, 123 .limits = iwlagn_p2p_sta_go_limits, 124 .n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits), 125 }, 126 { .num_different_channels = 1, 127 .max_interfaces = 2, 128 .limits = iwlagn_p2p_2sta_limits, 129 .n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits), 130 }, 131}; 132 133/* 134 * Not a mac80211 entry point function, but it fits in with all the 135 * other mac80211 functions grouped here. 136 */ 137int iwlagn_mac_setup_register(struct iwl_priv *priv, 138 const struct iwl_ucode_capabilities *capa) 139{ 140 int ret; 141 struct ieee80211_hw *hw = priv->hw; 142 struct iwl_rxon_context *ctx; 143 144 hw->rate_control_algorithm = "iwl-agn-rs"; 145 146 /* Tell mac80211 our characteristics */ 147 hw->flags = IEEE80211_HW_SIGNAL_DBM | 148 IEEE80211_HW_AMPDU_AGGREGATION | 149 IEEE80211_HW_NEED_DTIM_PERIOD | 150 IEEE80211_HW_SPECTRUM_MGMT | 151 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 152 IEEE80211_HW_QUEUE_CONTROL | 153 IEEE80211_HW_SUPPORTS_PS | 154 IEEE80211_HW_SUPPORTS_DYNAMIC_PS | 155 IEEE80211_HW_WANT_MONITOR_VIF | 156 IEEE80211_HW_SCAN_WHILE_IDLE; 157 158 hw->offchannel_tx_hw_queue = IWL_AUX_QUEUE; 159 hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FMT; 160 161 /* 162 * Including the following line will crash some AP's. This 163 * workaround removes the stimulus which causes the crash until 164 * the AP software can be fixed. 165 hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF; 166 */ 167 168 if (priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE) 169 hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS | 170 IEEE80211_HW_SUPPORTS_STATIC_SMPS; 171 172#ifndef CONFIG_IWLWIFI_EXPERIMENTAL_MFP 173 /* enable 11w if the uCode advertise */ 174 if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP) 175#endif /* !CONFIG_IWLWIFI_EXPERIMENTAL_MFP */ 176 hw->flags |= IEEE80211_HW_MFP_CAPABLE; 177 178 hw->sta_data_size = sizeof(struct iwl_station_priv); 179 hw->vif_data_size = sizeof(struct iwl_vif_priv); 180 181 for_each_context(priv, ctx) { 182 hw->wiphy->interface_modes |= ctx->interface_modes; 183 hw->wiphy->interface_modes |= ctx->exclusive_interface_modes; 184 } 185 186 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2); 187 188 if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) { 189 hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p; 190 hw->wiphy->n_iface_combinations = 191 ARRAY_SIZE(iwlagn_iface_combinations_p2p); 192 } else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) { 193 hw->wiphy->iface_combinations = 194 iwlagn_iface_combinations_dualmode; 195 hw->wiphy->n_iface_combinations = 196 ARRAY_SIZE(iwlagn_iface_combinations_dualmode); 197 } 198 199 hw->wiphy->max_remain_on_channel_duration = 1000; 200 201 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY | 202 WIPHY_FLAG_DISABLE_BEACON_HINTS | 203 WIPHY_FLAG_IBSS_RSN; 204 205 if (priv->fw->img[IWL_UCODE_WOWLAN].sec[0].len && 206 priv->trans->ops->wowlan_suspend && 207 device_can_wakeup(priv->trans->dev)) { 208 hw->wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT | 209 WIPHY_WOWLAN_DISCONNECT | 210 WIPHY_WOWLAN_EAP_IDENTITY_REQ | 211 WIPHY_WOWLAN_RFKILL_RELEASE; 212 if (!iwlwifi_mod_params.sw_crypto) 213 hw->wiphy->wowlan.flags |= 214 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | 215 WIPHY_WOWLAN_GTK_REKEY_FAILURE; 216 217 hw->wiphy->wowlan.n_patterns = IWLAGN_WOWLAN_MAX_PATTERNS; 218 hw->wiphy->wowlan.pattern_min_len = 219 IWLAGN_WOWLAN_MIN_PATTERN_LEN; 220 hw->wiphy->wowlan.pattern_max_len = 221 IWLAGN_WOWLAN_MAX_PATTERN_LEN; 222 } 223 224 if (iwlwifi_mod_params.power_save) 225 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; 226 else 227 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 228 229 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX; 230 /* we create the 802.11 header and a max-length SSID element */ 231 hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 34; 232 233 /* 234 * We don't use all queues: 4 and 9 are unused and any 235 * aggregation queue gets mapped down to the AC queue. 236 */ 237 hw->queues = IWLAGN_FIRST_AMPDU_QUEUE; 238 239 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL; 240 241 if (priv->bands[IEEE80211_BAND_2GHZ].n_channels) 242 priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = 243 &priv->bands[IEEE80211_BAND_2GHZ]; 244 if (priv->bands[IEEE80211_BAND_5GHZ].n_channels) 245 priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = 246 &priv->bands[IEEE80211_BAND_5GHZ]; 247 248 hw->wiphy->hw_version = priv->trans->hw_id; 249 250 iwl_leds_init(priv); 251 252 ret = ieee80211_register_hw(priv->hw); 253 if (ret) { 254 IWL_ERR(priv, "Failed to register hw (error %d)\n", ret); 255 return ret; 256 } 257 priv->mac80211_registered = 1; 258 259 return 0; 260} 261 262void iwlagn_mac_unregister(struct iwl_priv *priv) 263{ 264 if (!priv->mac80211_registered) 265 return; 266 iwl_leds_exit(priv); 267 ieee80211_unregister_hw(priv->hw); 268 priv->mac80211_registered = 0; 269} 270 271static int __iwl_up(struct iwl_priv *priv) 272{ 273 struct iwl_rxon_context *ctx; 274 int ret; 275 276 lockdep_assert_held(&priv->mutex); 277 278 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) { 279 IWL_WARN(priv, "Exit pending; will not bring the NIC up\n"); 280 return -EIO; 281 } 282 283 for_each_context(priv, ctx) { 284 ret = iwlagn_alloc_bcast_station(priv, ctx); 285 if (ret) { 286 iwl_dealloc_bcast_stations(priv); 287 return ret; 288 } 289 } 290 291 ret = iwl_run_init_ucode(priv); 292 if (ret) { 293 IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret); 294 goto error; 295 } 296 297 ret = iwl_load_ucode_wait_alive(priv, IWL_UCODE_REGULAR); 298 if (ret) { 299 IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret); 300 goto error; 301 } 302 303 ret = iwl_alive_start(priv); 304 if (ret) 305 goto error; 306 return 0; 307 308 error: 309 set_bit(STATUS_EXIT_PENDING, &priv->status); 310 iwl_down(priv); 311 clear_bit(STATUS_EXIT_PENDING, &priv->status); 312 313 IWL_ERR(priv, "Unable to initialize device.\n"); 314 return ret; 315} 316 317static int iwlagn_mac_start(struct ieee80211_hw *hw) 318{ 319 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 320 int ret; 321 322 IWL_DEBUG_MAC80211(priv, "enter\n"); 323 324 /* we should be verifying the device is ready to be opened */ 325 mutex_lock(&priv->mutex); 326 ret = __iwl_up(priv); 327 mutex_unlock(&priv->mutex); 328 if (ret) 329 return ret; 330 331 IWL_DEBUG_INFO(priv, "Start UP work done.\n"); 332 333 /* Now we should be done, and the READY bit should be set. */ 334 if (WARN_ON(!test_bit(STATUS_READY, &priv->status))) 335 ret = -EIO; 336 337 iwlagn_led_enable(priv); 338 339 priv->is_open = 1; 340 IWL_DEBUG_MAC80211(priv, "leave\n"); 341 return 0; 342} 343 344static void iwlagn_mac_stop(struct ieee80211_hw *hw) 345{ 346 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 347 348 IWL_DEBUG_MAC80211(priv, "enter\n"); 349 350 if (!priv->is_open) 351 return; 352 353 priv->is_open = 0; 354 355 mutex_lock(&priv->mutex); 356 iwl_down(priv); 357 mutex_unlock(&priv->mutex); 358 359 iwl_cancel_deferred_work(priv); 360 361 flush_workqueue(priv->workqueue); 362 363 /* User space software may expect getting rfkill changes 364 * even if interface is down, trans->down will leave the RF 365 * kill interrupt enabled 366 */ 367 iwl_trans_stop_hw(priv->trans, false); 368 369 IWL_DEBUG_MAC80211(priv, "leave\n"); 370} 371 372static void iwlagn_mac_set_rekey_data(struct ieee80211_hw *hw, 373 struct ieee80211_vif *vif, 374 struct cfg80211_gtk_rekey_data *data) 375{ 376 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 377 378 if (iwlwifi_mod_params.sw_crypto) 379 return; 380 381 IWL_DEBUG_MAC80211(priv, "enter\n"); 382 mutex_lock(&priv->mutex); 383 384 if (priv->contexts[IWL_RXON_CTX_BSS].vif != vif) 385 goto out; 386 387 memcpy(priv->kek, data->kek, NL80211_KEK_LEN); 388 memcpy(priv->kck, data->kck, NL80211_KCK_LEN); 389 priv->replay_ctr = 390 cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr)); 391 priv->have_rekey_data = true; 392 393 out: 394 mutex_unlock(&priv->mutex); 395 IWL_DEBUG_MAC80211(priv, "leave\n"); 396} 397 398#ifdef CONFIG_PM_SLEEP 399 400static int iwlagn_mac_suspend(struct ieee80211_hw *hw, 401 struct cfg80211_wowlan *wowlan) 402{ 403 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 404 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 405 int ret; 406 407 if (WARN_ON(!wowlan)) 408 return -EINVAL; 409 410 IWL_DEBUG_MAC80211(priv, "enter\n"); 411 mutex_lock(&priv->mutex); 412 413 /* Don't attempt WoWLAN when not associated, tear down instead. */ 414 if (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION || 415 !iwl_is_associated_ctx(ctx)) { 416 ret = 1; 417 goto out; 418 } 419 420 ret = iwlagn_suspend(priv, wowlan); 421 if (ret) 422 goto error; 423 424 iwl_trans_wowlan_suspend(priv->trans); 425 426 goto out; 427 428 error: 429 priv->wowlan = false; 430 iwlagn_prepare_restart(priv); 431 ieee80211_restart_hw(priv->hw); 432 out: 433 mutex_unlock(&priv->mutex); 434 IWL_DEBUG_MAC80211(priv, "leave\n"); 435 436 return ret; 437} 438 439static int iwlagn_mac_resume(struct ieee80211_hw *hw) 440{ 441 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 442 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 443 struct ieee80211_vif *vif; 444 unsigned long flags; 445 u32 base, status = 0xffffffff; 446 int ret = -EIO; 447 448 IWL_DEBUG_MAC80211(priv, "enter\n"); 449 mutex_lock(&priv->mutex); 450 451 iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_CLR, 452 CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE); 453 454 base = priv->device_pointers.error_event_table; 455 if (iwlagn_hw_valid_rtc_data_addr(base)) { 456 spin_lock_irqsave(&priv->trans->reg_lock, flags); 457 ret = iwl_grab_nic_access_silent(priv->trans); 458 if (likely(ret == 0)) { 459 iwl_write32(priv->trans, HBUS_TARG_MEM_RADDR, base); 460 status = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT); 461 iwl_release_nic_access(priv->trans); 462 } 463 spin_unlock_irqrestore(&priv->trans->reg_lock, flags); 464 465#ifdef CONFIG_IWLWIFI_DEBUGFS 466 if (ret == 0) { 467 const struct fw_img *img; 468 469 img = &(priv->fw->img[IWL_UCODE_WOWLAN]); 470 if (!priv->wowlan_sram) { 471 priv->wowlan_sram = 472 kzalloc(img->sec[IWL_UCODE_SECTION_DATA].len, 473 GFP_KERNEL); 474 } 475 476 if (priv->wowlan_sram) 477 _iwl_read_targ_mem_words( 478 priv->trans, 0x800000, 479 priv->wowlan_sram, 480 img->sec[IWL_UCODE_SECTION_DATA].len / 4); 481 } 482#endif 483 } 484 485 /* we'll clear ctx->vif during iwlagn_prepare_restart() */ 486 vif = ctx->vif; 487 488 priv->wowlan = false; 489 490 iwlagn_prepare_restart(priv); 491 492 memset((void *)&ctx->active, 0, sizeof(ctx->active)); 493 iwl_connection_init_rx_config(priv, ctx); 494 iwlagn_set_rxon_chain(priv, ctx); 495 496 mutex_unlock(&priv->mutex); 497 IWL_DEBUG_MAC80211(priv, "leave\n"); 498 499 ieee80211_resume_disconnect(vif); 500 501 return 1; 502} 503 504static void iwlagn_mac_set_wakeup(struct ieee80211_hw *hw, bool enabled) 505{ 506 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 507 508 device_set_wakeup_enable(priv->trans->dev, enabled); 509} 510#endif 511 512static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb) 513{ 514 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 515 516 IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len, 517 ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate); 518 519 if (iwlagn_tx_skb(priv, skb)) 520 dev_kfree_skb_any(skb); 521} 522 523static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw, 524 struct ieee80211_vif *vif, 525 struct ieee80211_key_conf *keyconf, 526 struct ieee80211_sta *sta, 527 u32 iv32, u16 *phase1key) 528{ 529 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 530 531 iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key); 532} 533 534static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 535 struct ieee80211_vif *vif, 536 struct ieee80211_sta *sta, 537 struct ieee80211_key_conf *key) 538{ 539 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 540 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv; 541 struct iwl_rxon_context *ctx = vif_priv->ctx; 542 int ret; 543 bool is_default_wep_key = false; 544 545 IWL_DEBUG_MAC80211(priv, "enter\n"); 546 547 if (iwlwifi_mod_params.sw_crypto) { 548 IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n"); 549 return -EOPNOTSUPP; 550 } 551 552 switch (key->cipher) { 553 case WLAN_CIPHER_SUITE_TKIP: 554 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; 555 /* fall through */ 556 case WLAN_CIPHER_SUITE_CCMP: 557 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 558 break; 559 default: 560 break; 561 } 562 563 /* 564 * We could program these keys into the hardware as well, but we 565 * don't expect much multicast traffic in IBSS and having keys 566 * for more stations is probably more useful. 567 * 568 * Mark key TX-only and return 0. 569 */ 570 if (vif->type == NL80211_IFTYPE_ADHOC && 571 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) { 572 key->hw_key_idx = WEP_INVALID_OFFSET; 573 return 0; 574 } 575 576 /* If they key was TX-only, accept deletion */ 577 if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET) 578 return 0; 579 580 mutex_lock(&priv->mutex); 581 iwl_scan_cancel_timeout(priv, 100); 582 583 BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT); 584 585 /* 586 * If we are getting WEP group key and we didn't receive any key mapping 587 * so far, we are in legacy wep mode (group key only), otherwise we are 588 * in 1X mode. 589 * In legacy wep mode, we use another host command to the uCode. 590 */ 591 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 || 592 key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) { 593 if (cmd == SET_KEY) 594 is_default_wep_key = !ctx->key_mapping_keys; 595 else 596 is_default_wep_key = 597 key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT; 598 } 599 600 601 switch (cmd) { 602 case SET_KEY: 603 if (is_default_wep_key) { 604 ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key); 605 break; 606 } 607 ret = iwl_set_dynamic_key(priv, vif_priv->ctx, key, sta); 608 if (ret) { 609 /* 610 * can't add key for RX, but we don't need it 611 * in the device for TX so still return 0 612 */ 613 ret = 0; 614 key->hw_key_idx = WEP_INVALID_OFFSET; 615 } 616 617 IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n"); 618 break; 619 case DISABLE_KEY: 620 if (is_default_wep_key) 621 ret = iwl_remove_default_wep_key(priv, ctx, key); 622 else 623 ret = iwl_remove_dynamic_key(priv, ctx, key, sta); 624 625 IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n"); 626 break; 627 default: 628 ret = -EINVAL; 629 } 630 631 mutex_unlock(&priv->mutex); 632 IWL_DEBUG_MAC80211(priv, "leave\n"); 633 634 return ret; 635} 636 637static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw, 638 struct ieee80211_vif *vif, 639 enum ieee80211_ampdu_mlme_action action, 640 struct ieee80211_sta *sta, u16 tid, u16 *ssn, 641 u8 buf_size) 642{ 643 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 644 int ret = -EINVAL; 645 struct iwl_station_priv *sta_priv = (void *) sta->drv_priv; 646 647 IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n", 648 sta->addr, tid); 649 650 if (!(priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE)) 651 return -EACCES; 652 653 IWL_DEBUG_MAC80211(priv, "enter\n"); 654 mutex_lock(&priv->mutex); 655 656 switch (action) { 657 case IEEE80211_AMPDU_RX_START: 658 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_RXAGG) 659 break; 660 IWL_DEBUG_HT(priv, "start Rx\n"); 661 ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn); 662 break; 663 case IEEE80211_AMPDU_RX_STOP: 664 IWL_DEBUG_HT(priv, "stop Rx\n"); 665 ret = iwl_sta_rx_agg_stop(priv, sta, tid); 666 break; 667 case IEEE80211_AMPDU_TX_START: 668 if (!priv->trans->ops->tx_agg_setup) 669 break; 670 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_TXAGG) 671 break; 672 IWL_DEBUG_HT(priv, "start Tx\n"); 673 ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn); 674 break; 675 case IEEE80211_AMPDU_TX_STOP: 676 IWL_DEBUG_HT(priv, "stop Tx\n"); 677 ret = iwlagn_tx_agg_stop(priv, vif, sta, tid); 678 if ((ret == 0) && (priv->agg_tids_count > 0)) { 679 priv->agg_tids_count--; 680 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n", 681 priv->agg_tids_count); 682 } 683 if (!priv->agg_tids_count && 684 priv->hw_params.use_rts_for_aggregation) { 685 /* 686 * switch off RTS/CTS if it was previously enabled 687 */ 688 sta_priv->lq_sta.lq.general_params.flags &= 689 ~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK; 690 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif), 691 &sta_priv->lq_sta.lq, CMD_ASYNC, false); 692 } 693 break; 694 case IEEE80211_AMPDU_TX_OPERATIONAL: 695 ret = iwlagn_tx_agg_oper(priv, vif, sta, tid, buf_size); 696 break; 697 } 698 mutex_unlock(&priv->mutex); 699 IWL_DEBUG_MAC80211(priv, "leave\n"); 700 return ret; 701} 702 703static int iwlagn_mac_sta_add(struct ieee80211_hw *hw, 704 struct ieee80211_vif *vif, 705 struct ieee80211_sta *sta) 706{ 707 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 708 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv; 709 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv; 710 bool is_ap = vif->type == NL80211_IFTYPE_STATION; 711 int ret; 712 u8 sta_id; 713 714 IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n", 715 sta->addr); 716 sta_priv->sta_id = IWL_INVALID_STATION; 717 718 atomic_set(&sta_priv->pending_frames, 0); 719 if (vif->type == NL80211_IFTYPE_AP) 720 sta_priv->client = true; 721 722 ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr, 723 is_ap, sta, &sta_id); 724 if (ret) { 725 IWL_ERR(priv, "Unable to add station %pM (%d)\n", 726 sta->addr, ret); 727 /* Should we return success if return code is EEXIST ? */ 728 return ret; 729 } 730 731 sta_priv->sta_id = sta_id; 732 733 return 0; 734} 735 736static int iwlagn_mac_sta_remove(struct ieee80211_hw *hw, 737 struct ieee80211_vif *vif, 738 struct ieee80211_sta *sta) 739{ 740 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 741 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv; 742 int ret; 743 744 IWL_DEBUG_INFO(priv, "proceeding to remove station %pM\n", sta->addr); 745 746 if (vif->type == NL80211_IFTYPE_STATION) { 747 /* 748 * Station will be removed from device when the RXON 749 * is set to unassociated -- just deactivate it here 750 * to avoid re-programming it. 751 */ 752 ret = 0; 753 iwl_deactivate_station(priv, sta_priv->sta_id, sta->addr); 754 } else { 755 ret = iwl_remove_station(priv, sta_priv->sta_id, sta->addr); 756 if (ret) 757 IWL_DEBUG_QUIET_RFKILL(priv, 758 "Error removing station %pM\n", sta->addr); 759 } 760 return ret; 761} 762 763static int iwlagn_mac_sta_state(struct ieee80211_hw *hw, 764 struct ieee80211_vif *vif, 765 struct ieee80211_sta *sta, 766 enum ieee80211_sta_state old_state, 767 enum ieee80211_sta_state new_state) 768{ 769 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 770 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv; 771 enum { 772 NONE, ADD, REMOVE, HT_RATE_INIT, ADD_RATE_INIT, 773 } op = NONE; 774 int ret; 775 776 IWL_DEBUG_MAC80211(priv, "station %pM state change %d->%d\n", 777 sta->addr, old_state, new_state); 778 779 mutex_lock(&priv->mutex); 780 if (vif->type == NL80211_IFTYPE_STATION) { 781 if (old_state == IEEE80211_STA_NOTEXIST && 782 new_state == IEEE80211_STA_NONE) 783 op = ADD; 784 else if (old_state == IEEE80211_STA_NONE && 785 new_state == IEEE80211_STA_NOTEXIST) 786 op = REMOVE; 787 else if (old_state == IEEE80211_STA_AUTH && 788 new_state == IEEE80211_STA_ASSOC) 789 op = HT_RATE_INIT; 790 } else { 791 if (old_state == IEEE80211_STA_AUTH && 792 new_state == IEEE80211_STA_ASSOC) 793 op = ADD_RATE_INIT; 794 else if (old_state == IEEE80211_STA_ASSOC && 795 new_state == IEEE80211_STA_AUTH) 796 op = REMOVE; 797 } 798 799 switch (op) { 800 case ADD: 801 ret = iwlagn_mac_sta_add(hw, vif, sta); 802 break; 803 case REMOVE: 804 ret = iwlagn_mac_sta_remove(hw, vif, sta); 805 break; 806 case ADD_RATE_INIT: 807 ret = iwlagn_mac_sta_add(hw, vif, sta); 808 if (ret) 809 break; 810 /* Initialize rate scaling */ 811 IWL_DEBUG_INFO(priv, 812 "Initializing rate scaling for station %pM\n", 813 sta->addr); 814 iwl_rs_rate_init(priv, sta, iwl_sta_id(sta)); 815 ret = 0; 816 break; 817 case HT_RATE_INIT: 818 /* Initialize rate scaling */ 819 ret = iwl_sta_update_ht(priv, vif_priv->ctx, sta); 820 if (ret) 821 break; 822 IWL_DEBUG_INFO(priv, 823 "Initializing rate scaling for station %pM\n", 824 sta->addr); 825 iwl_rs_rate_init(priv, sta, iwl_sta_id(sta)); 826 ret = 0; 827 break; 828 default: 829 ret = 0; 830 break; 831 } 832 833 /* 834 * mac80211 might WARN if we fail, but due the way we 835 * (badly) handle hard rfkill, we might fail here 836 */ 837 if (iwl_is_rfkill(priv)) 838 ret = 0; 839 840 mutex_unlock(&priv->mutex); 841 IWL_DEBUG_MAC80211(priv, "leave\n"); 842 843 return ret; 844} 845 846static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw, 847 struct ieee80211_channel_switch *ch_switch) 848{ 849 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 850 struct ieee80211_conf *conf = &hw->conf; 851 struct ieee80211_channel *channel = ch_switch->channel; 852 struct iwl_ht_config *ht_conf = &priv->current_ht_config; 853 /* 854 * MULTI-FIXME 855 * When we add support for multiple interfaces, we need to 856 * revisit this. The channel switch command in the device 857 * only affects the BSS context, but what does that really 858 * mean? And what if we get a CSA on the second interface? 859 * This needs a lot of work. 860 */ 861 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 862 u16 ch; 863 864 IWL_DEBUG_MAC80211(priv, "enter\n"); 865 866 mutex_lock(&priv->mutex); 867 868 if (iwl_is_rfkill(priv)) 869 goto out; 870 871 if (test_bit(STATUS_EXIT_PENDING, &priv->status) || 872 test_bit(STATUS_SCANNING, &priv->status) || 873 test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status)) 874 goto out; 875 876 if (!iwl_is_associated_ctx(ctx)) 877 goto out; 878 879 if (!priv->lib->set_channel_switch) 880 goto out; 881 882 ch = channel->hw_value; 883 if (le16_to_cpu(ctx->active.channel) == ch) 884 goto out; 885 886 priv->current_ht_config.smps = conf->smps_mode; 887 888 /* Configure HT40 channels */ 889 ctx->ht.enabled = conf_is_ht(conf); 890 if (ctx->ht.enabled) 891 iwlagn_config_ht40(conf, ctx); 892 else 893 ctx->ht.is_40mhz = false; 894 895 if ((le16_to_cpu(ctx->staging.channel) != ch)) 896 ctx->staging.flags = 0; 897 898 iwl_set_rxon_channel(priv, channel, ctx); 899 iwl_set_rxon_ht(priv, ht_conf); 900 iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif); 901 902 /* 903 * at this point, staging_rxon has the 904 * configuration for channel switch 905 */ 906 set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status); 907 priv->switch_channel = cpu_to_le16(ch); 908 if (priv->lib->set_channel_switch(priv, ch_switch)) { 909 clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status); 910 priv->switch_channel = 0; 911 ieee80211_chswitch_done(ctx->vif, false); 912 } 913 914out: 915 mutex_unlock(&priv->mutex); 916 IWL_DEBUG_MAC80211(priv, "leave\n"); 917} 918 919void iwl_chswitch_done(struct iwl_priv *priv, bool is_success) 920{ 921 /* 922 * MULTI-FIXME 923 * See iwlagn_mac_channel_switch. 924 */ 925 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 926 927 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) 928 return; 929 930 if (test_and_clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status)) 931 ieee80211_chswitch_done(ctx->vif, is_success); 932} 933 934static void iwlagn_configure_filter(struct ieee80211_hw *hw, 935 unsigned int changed_flags, 936 unsigned int *total_flags, 937 u64 multicast) 938{ 939 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 940 __le32 filter_or = 0, filter_nand = 0; 941 struct iwl_rxon_context *ctx; 942 943#define CHK(test, flag) do { \ 944 if (*total_flags & (test)) \ 945 filter_or |= (flag); \ 946 else \ 947 filter_nand |= (flag); \ 948 } while (0) 949 950 IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n", 951 changed_flags, *total_flags); 952 953 CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK); 954 /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */ 955 CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK); 956 CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK); 957 958#undef CHK 959 960 mutex_lock(&priv->mutex); 961 962 for_each_context(priv, ctx) { 963 ctx->staging.filter_flags &= ~filter_nand; 964 ctx->staging.filter_flags |= filter_or; 965 966 /* 967 * Not committing directly because hardware can perform a scan, 968 * but we'll eventually commit the filter flags change anyway. 969 */ 970 } 971 972 mutex_unlock(&priv->mutex); 973 974 /* 975 * Receiving all multicast frames is always enabled by the 976 * default flags setup in iwl_connection_init_rx_config() 977 * since we currently do not support programming multicast 978 * filters into the device. 979 */ 980 *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS | 981 FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL; 982} 983 984static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop) 985{ 986 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 987 988 mutex_lock(&priv->mutex); 989 IWL_DEBUG_MAC80211(priv, "enter\n"); 990 991 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) { 992 IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n"); 993 goto done; 994 } 995 if (iwl_is_rfkill(priv)) { 996 IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n"); 997 goto done; 998 } 999 1000 /* 1001 * mac80211 will not push any more frames for transmit 1002 * until the flush is completed 1003 */ 1004 if (drop) { 1005 IWL_DEBUG_MAC80211(priv, "send flush command\n"); 1006 if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) { 1007 IWL_ERR(priv, "flush request fail\n"); 1008 goto done; 1009 } 1010 } 1011 IWL_DEBUG_MAC80211(priv, "wait transmit/flush all frames\n"); 1012 iwl_trans_wait_tx_queue_empty(priv->trans); 1013done: 1014 mutex_unlock(&priv->mutex); 1015 IWL_DEBUG_MAC80211(priv, "leave\n"); 1016} 1017 1018static int iwlagn_mac_remain_on_channel(struct ieee80211_hw *hw, 1019 struct ieee80211_channel *channel, 1020 enum nl80211_channel_type channel_type, 1021 int duration) 1022{ 1023 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1024 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN]; 1025 int err = 0; 1026 1027 if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN))) 1028 return -EOPNOTSUPP; 1029 1030 if (!(ctx->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT))) 1031 return -EOPNOTSUPP; 1032 1033 IWL_DEBUG_MAC80211(priv, "enter\n"); 1034 mutex_lock(&priv->mutex); 1035 1036 if (test_bit(STATUS_SCAN_HW, &priv->status)) { 1037 err = -EBUSY; 1038 goto out; 1039 } 1040 1041 priv->hw_roc_channel = channel; 1042 priv->hw_roc_chantype = channel_type; 1043 /* convert from ms to TU */ 1044 priv->hw_roc_duration = DIV_ROUND_UP(1000 * duration, 1024); 1045 priv->hw_roc_start_notified = false; 1046 cancel_delayed_work(&priv->hw_roc_disable_work); 1047 1048 if (!ctx->is_active) { 1049 static const struct iwl_qos_info default_qos_data = { 1050 .def_qos_parm = { 1051 .ac[0] = { 1052 .cw_min = cpu_to_le16(3), 1053 .cw_max = cpu_to_le16(7), 1054 .aifsn = 2, 1055 .edca_txop = cpu_to_le16(1504), 1056 }, 1057 .ac[1] = { 1058 .cw_min = cpu_to_le16(7), 1059 .cw_max = cpu_to_le16(15), 1060 .aifsn = 2, 1061 .edca_txop = cpu_to_le16(3008), 1062 }, 1063 .ac[2] = { 1064 .cw_min = cpu_to_le16(15), 1065 .cw_max = cpu_to_le16(1023), 1066 .aifsn = 3, 1067 }, 1068 .ac[3] = { 1069 .cw_min = cpu_to_le16(15), 1070 .cw_max = cpu_to_le16(1023), 1071 .aifsn = 7, 1072 }, 1073 }, 1074 }; 1075 1076 ctx->is_active = true; 1077 ctx->qos_data = default_qos_data; 1078 ctx->staging.dev_type = RXON_DEV_TYPE_P2P; 1079 memcpy(ctx->staging.node_addr, 1080 priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr, 1081 ETH_ALEN); 1082 memcpy(ctx->staging.bssid_addr, 1083 priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr, 1084 ETH_ALEN); 1085 err = iwlagn_commit_rxon(priv, ctx); 1086 if (err) 1087 goto out; 1088 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK | 1089 RXON_FILTER_PROMISC_MSK | 1090 RXON_FILTER_CTL2HOST_MSK; 1091 1092 err = iwlagn_commit_rxon(priv, ctx); 1093 if (err) { 1094 iwlagn_disable_roc(priv); 1095 goto out; 1096 } 1097 priv->hw_roc_setup = true; 1098 } 1099 1100 err = iwl_scan_initiate(priv, ctx->vif, IWL_SCAN_ROC, channel->band); 1101 if (err) 1102 iwlagn_disable_roc(priv); 1103 1104 out: 1105 mutex_unlock(&priv->mutex); 1106 IWL_DEBUG_MAC80211(priv, "leave\n"); 1107 1108 return err; 1109} 1110 1111static int iwlagn_mac_cancel_remain_on_channel(struct ieee80211_hw *hw) 1112{ 1113 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1114 1115 if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN))) 1116 return -EOPNOTSUPP; 1117 1118 IWL_DEBUG_MAC80211(priv, "enter\n"); 1119 mutex_lock(&priv->mutex); 1120 iwl_scan_cancel_timeout(priv, priv->hw_roc_duration); 1121 iwlagn_disable_roc(priv); 1122 mutex_unlock(&priv->mutex); 1123 IWL_DEBUG_MAC80211(priv, "leave\n"); 1124 1125 return 0; 1126} 1127 1128static void iwlagn_mac_rssi_callback(struct ieee80211_hw *hw, 1129 enum ieee80211_rssi_event rssi_event) 1130{ 1131 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1132 1133 IWL_DEBUG_MAC80211(priv, "enter\n"); 1134 mutex_lock(&priv->mutex); 1135 1136 if (priv->cfg->bt_params && 1137 priv->cfg->bt_params->advanced_bt_coexist) { 1138 if (rssi_event == RSSI_EVENT_LOW) 1139 priv->bt_enable_pspoll = true; 1140 else if (rssi_event == RSSI_EVENT_HIGH) 1141 priv->bt_enable_pspoll = false; 1142 1143 iwlagn_send_advance_bt_config(priv); 1144 } else { 1145 IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled," 1146 "ignoring RSSI callback\n"); 1147 } 1148 1149 mutex_unlock(&priv->mutex); 1150 IWL_DEBUG_MAC80211(priv, "leave\n"); 1151} 1152 1153static int iwlagn_mac_set_tim(struct ieee80211_hw *hw, 1154 struct ieee80211_sta *sta, bool set) 1155{ 1156 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1157 1158 queue_work(priv->workqueue, &priv->beacon_update); 1159 1160 return 0; 1161} 1162 1163static int iwlagn_mac_conf_tx(struct ieee80211_hw *hw, 1164 struct ieee80211_vif *vif, u16 queue, 1165 const struct ieee80211_tx_queue_params *params) 1166{ 1167 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1168 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv; 1169 struct iwl_rxon_context *ctx = vif_priv->ctx; 1170 int q; 1171 1172 if (WARN_ON(!ctx)) 1173 return -EINVAL; 1174 1175 IWL_DEBUG_MAC80211(priv, "enter\n"); 1176 1177 if (!iwl_is_ready_rf(priv)) { 1178 IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n"); 1179 return -EIO; 1180 } 1181 1182 if (queue >= AC_NUM) { 1183 IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue); 1184 return 0; 1185 } 1186 1187 q = AC_NUM - 1 - queue; 1188 1189 mutex_lock(&priv->mutex); 1190 1191 ctx->qos_data.def_qos_parm.ac[q].cw_min = 1192 cpu_to_le16(params->cw_min); 1193 ctx->qos_data.def_qos_parm.ac[q].cw_max = 1194 cpu_to_le16(params->cw_max); 1195 ctx->qos_data.def_qos_parm.ac[q].aifsn = params->aifs; 1196 ctx->qos_data.def_qos_parm.ac[q].edca_txop = 1197 cpu_to_le16((params->txop * 32)); 1198 1199 ctx->qos_data.def_qos_parm.ac[q].reserved1 = 0; 1200 1201 mutex_unlock(&priv->mutex); 1202 1203 IWL_DEBUG_MAC80211(priv, "leave\n"); 1204 return 0; 1205} 1206 1207static int iwlagn_mac_tx_last_beacon(struct ieee80211_hw *hw) 1208{ 1209 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1210 1211 return priv->ibss_manager == IWL_IBSS_MANAGER; 1212} 1213 1214static int iwl_set_mode(struct iwl_priv *priv, struct iwl_rxon_context *ctx) 1215{ 1216 iwl_connection_init_rx_config(priv, ctx); 1217 1218 iwlagn_set_rxon_chain(priv, ctx); 1219 1220 return iwlagn_commit_rxon(priv, ctx); 1221} 1222 1223static int iwl_setup_interface(struct iwl_priv *priv, 1224 struct iwl_rxon_context *ctx) 1225{ 1226 struct ieee80211_vif *vif = ctx->vif; 1227 int err, ac; 1228 1229 lockdep_assert_held(&priv->mutex); 1230 1231 /* 1232 * This variable will be correct only when there's just 1233 * a single context, but all code using it is for hardware 1234 * that supports only one context. 1235 */ 1236 priv->iw_mode = vif->type; 1237 1238 ctx->is_active = true; 1239 1240 err = iwl_set_mode(priv, ctx); 1241 if (err) { 1242 if (!ctx->always_active) 1243 ctx->is_active = false; 1244 return err; 1245 } 1246 1247 if (priv->cfg->bt_params && priv->cfg->bt_params->advanced_bt_coexist && 1248 vif->type == NL80211_IFTYPE_ADHOC) { 1249 /* 1250 * pretend to have high BT traffic as long as we 1251 * are operating in IBSS mode, as this will cause 1252 * the rate scaling etc. to behave as intended. 1253 */ 1254 priv->bt_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_HIGH; 1255 } 1256 1257 /* set up queue mappings */ 1258 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) 1259 vif->hw_queue[ac] = ctx->ac_to_queue[ac]; 1260 1261 if (vif->type == NL80211_IFTYPE_AP) 1262 vif->cab_queue = ctx->mcast_queue; 1263 else 1264 vif->cab_queue = IEEE80211_INVAL_HW_QUEUE; 1265 1266 return 0; 1267} 1268 1269static int iwlagn_mac_add_interface(struct ieee80211_hw *hw, 1270 struct ieee80211_vif *vif) 1271{ 1272 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1273 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv; 1274 struct iwl_rxon_context *tmp, *ctx = NULL; 1275 int err; 1276 enum nl80211_iftype viftype = ieee80211_vif_type_p2p(vif); 1277 bool reset = false; 1278 1279 IWL_DEBUG_MAC80211(priv, "enter: type %d, addr %pM\n", 1280 viftype, vif->addr); 1281 1282 cancel_delayed_work_sync(&priv->hw_roc_disable_work); 1283 1284 mutex_lock(&priv->mutex); 1285 1286 iwlagn_disable_roc(priv); 1287 1288 if (!iwl_is_ready_rf(priv)) { 1289 IWL_WARN(priv, "Try to add interface when device not ready\n"); 1290 err = -EINVAL; 1291 goto out; 1292 } 1293 1294 for_each_context(priv, tmp) { 1295 u32 possible_modes = 1296 tmp->interface_modes | tmp->exclusive_interface_modes; 1297 1298 if (tmp->vif) { 1299 /* On reset we need to add the same interface again */ 1300 if (tmp->vif == vif) { 1301 reset = true; 1302 ctx = tmp; 1303 break; 1304 } 1305 1306 /* check if this busy context is exclusive */ 1307 if (tmp->exclusive_interface_modes & 1308 BIT(tmp->vif->type)) { 1309 err = -EINVAL; 1310 goto out; 1311 } 1312 continue; 1313 } 1314 1315 if (!(possible_modes & BIT(viftype))) 1316 continue; 1317 1318 /* have maybe usable context w/o interface */ 1319 ctx = tmp; 1320 break; 1321 } 1322 1323 if (!ctx) { 1324 err = -EOPNOTSUPP; 1325 goto out; 1326 } 1327 1328 vif_priv->ctx = ctx; 1329 ctx->vif = vif; 1330 1331 err = iwl_setup_interface(priv, ctx); 1332 if (!err || reset) 1333 goto out; 1334 1335 ctx->vif = NULL; 1336 priv->iw_mode = NL80211_IFTYPE_STATION; 1337 out: 1338 mutex_unlock(&priv->mutex); 1339 1340 IWL_DEBUG_MAC80211(priv, "leave\n"); 1341 return err; 1342} 1343 1344static void iwl_teardown_interface(struct iwl_priv *priv, 1345 struct ieee80211_vif *vif, 1346 bool mode_change) 1347{ 1348 struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif); 1349 1350 lockdep_assert_held(&priv->mutex); 1351 1352 if (priv->scan_vif == vif) { 1353 iwl_scan_cancel_timeout(priv, 200); 1354 iwl_force_scan_end(priv); 1355 } 1356 1357 if (!mode_change) { 1358 iwl_set_mode(priv, ctx); 1359 if (!ctx->always_active) 1360 ctx->is_active = false; 1361 } 1362 1363 /* 1364 * When removing the IBSS interface, overwrite the 1365 * BT traffic load with the stored one from the last 1366 * notification, if any. If this is a device that 1367 * doesn't implement this, this has no effect since 1368 * both values are the same and zero. 1369 */ 1370 if (vif->type == NL80211_IFTYPE_ADHOC) 1371 priv->bt_traffic_load = priv->last_bt_traffic_load; 1372} 1373 1374static void iwlagn_mac_remove_interface(struct ieee80211_hw *hw, 1375 struct ieee80211_vif *vif) 1376{ 1377 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1378 struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif); 1379 1380 IWL_DEBUG_MAC80211(priv, "enter\n"); 1381 1382 mutex_lock(&priv->mutex); 1383 1384 if (WARN_ON(ctx->vif != vif)) { 1385 struct iwl_rxon_context *tmp; 1386 IWL_ERR(priv, "ctx->vif = %p, vif = %p\n", ctx->vif, vif); 1387 for_each_context(priv, tmp) 1388 IWL_ERR(priv, "\tID = %d:\tctx = %p\tctx->vif = %p\n", 1389 tmp->ctxid, tmp, tmp->vif); 1390 } 1391 ctx->vif = NULL; 1392 1393 iwl_teardown_interface(priv, vif, false); 1394 1395 mutex_unlock(&priv->mutex); 1396 1397 IWL_DEBUG_MAC80211(priv, "leave\n"); 1398 1399} 1400 1401static int iwlagn_mac_change_interface(struct ieee80211_hw *hw, 1402 struct ieee80211_vif *vif, 1403 enum nl80211_iftype newtype, bool newp2p) 1404{ 1405 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1406 struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif); 1407 struct iwl_rxon_context *bss_ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 1408 struct iwl_rxon_context *tmp; 1409 enum nl80211_iftype newviftype = newtype; 1410 u32 interface_modes; 1411 int err; 1412 1413 IWL_DEBUG_MAC80211(priv, "enter\n"); 1414 1415 newtype = ieee80211_iftype_p2p(newtype, newp2p); 1416 1417 mutex_lock(&priv->mutex); 1418 1419 if (!ctx->vif || !iwl_is_ready_rf(priv)) { 1420 /* 1421 * Huh? But wait ... this can maybe happen when 1422 * we're in the middle of a firmware restart! 1423 */ 1424 err = -EBUSY; 1425 goto out; 1426 } 1427 1428 interface_modes = ctx->interface_modes | ctx->exclusive_interface_modes; 1429 1430 if (!(interface_modes & BIT(newtype))) { 1431 err = -EBUSY; 1432 goto out; 1433 } 1434 1435 /* 1436 * Refuse a change that should be done by moving from the PAN 1437 * context to the BSS context instead, if the BSS context is 1438 * available and can support the new interface type. 1439 */ 1440 if (ctx->ctxid == IWL_RXON_CTX_PAN && !bss_ctx->vif && 1441 (bss_ctx->interface_modes & BIT(newtype) || 1442 bss_ctx->exclusive_interface_modes & BIT(newtype))) { 1443 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2); 1444 err = -EBUSY; 1445 goto out; 1446 } 1447 1448 if (ctx->exclusive_interface_modes & BIT(newtype)) { 1449 for_each_context(priv, tmp) { 1450 if (ctx == tmp) 1451 continue; 1452 1453 if (!tmp->vif) 1454 continue; 1455 1456 /* 1457 * The current mode switch would be exclusive, but 1458 * another context is active ... refuse the switch. 1459 */ 1460 err = -EBUSY; 1461 goto out; 1462 } 1463 } 1464 1465 /* success */ 1466 iwl_teardown_interface(priv, vif, true); 1467 vif->type = newviftype; 1468 vif->p2p = newp2p; 1469 err = iwl_setup_interface(priv, ctx); 1470 WARN_ON(err); 1471 /* 1472 * We've switched internally, but submitting to the 1473 * device may have failed for some reason. Mask this 1474 * error, because otherwise mac80211 will not switch 1475 * (and set the interface type back) and we'll be 1476 * out of sync with it. 1477 */ 1478 err = 0; 1479 1480 out: 1481 mutex_unlock(&priv->mutex); 1482 IWL_DEBUG_MAC80211(priv, "leave\n"); 1483 1484 return err; 1485} 1486 1487static int iwlagn_mac_hw_scan(struct ieee80211_hw *hw, 1488 struct ieee80211_vif *vif, 1489 struct cfg80211_scan_request *req) 1490{ 1491 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1492 int ret; 1493 1494 IWL_DEBUG_MAC80211(priv, "enter\n"); 1495 1496 if (req->n_channels == 0) 1497 return -EINVAL; 1498 1499 mutex_lock(&priv->mutex); 1500 1501 /* 1502 * If an internal scan is in progress, just set 1503 * up the scan_request as per above. 1504 */ 1505 if (priv->scan_type != IWL_SCAN_NORMAL) { 1506 IWL_DEBUG_SCAN(priv, 1507 "SCAN request during internal scan - defer\n"); 1508 priv->scan_request = req; 1509 priv->scan_vif = vif; 1510 ret = 0; 1511 } else { 1512 priv->scan_request = req; 1513 priv->scan_vif = vif; 1514 /* 1515 * mac80211 will only ask for one band at a time 1516 * so using channels[0] here is ok 1517 */ 1518 ret = iwl_scan_initiate(priv, vif, IWL_SCAN_NORMAL, 1519 req->channels[0]->band); 1520 if (ret) { 1521 priv->scan_request = NULL; 1522 priv->scan_vif = NULL; 1523 } 1524 } 1525 1526 IWL_DEBUG_MAC80211(priv, "leave\n"); 1527 1528 mutex_unlock(&priv->mutex); 1529 1530 return ret; 1531} 1532 1533static void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id) 1534{ 1535 struct iwl_addsta_cmd cmd = { 1536 .mode = STA_CONTROL_MODIFY_MSK, 1537 .station_flags_msk = STA_FLG_PWR_SAVE_MSK, 1538 .sta.sta_id = sta_id, 1539 }; 1540 1541 iwl_send_add_sta(priv, &cmd, CMD_ASYNC); 1542} 1543 1544static void iwlagn_mac_sta_notify(struct ieee80211_hw *hw, 1545 struct ieee80211_vif *vif, 1546 enum sta_notify_cmd cmd, 1547 struct ieee80211_sta *sta) 1548{ 1549 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw); 1550 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv; 1551 int sta_id; 1552 1553 IWL_DEBUG_MAC80211(priv, "enter\n"); 1554 1555 switch (cmd) { 1556 case STA_NOTIFY_SLEEP: 1557 WARN_ON(!sta_priv->client); 1558 sta_priv->asleep = true; 1559 if (atomic_read(&sta_priv->pending_frames) > 0) 1560 ieee80211_sta_block_awake(hw, sta, true); 1561 break; 1562 case STA_NOTIFY_AWAKE: 1563 WARN_ON(!sta_priv->client); 1564 if (!sta_priv->asleep) 1565 break; 1566 sta_priv->asleep = false; 1567 sta_id = iwl_sta_id(sta); 1568 if (sta_id != IWL_INVALID_STATION) 1569 iwl_sta_modify_ps_wake(priv, sta_id); 1570 break; 1571 default: 1572 break; 1573 } 1574 IWL_DEBUG_MAC80211(priv, "leave\n"); 1575} 1576 1577struct ieee80211_ops iwlagn_hw_ops = { 1578 .tx = iwlagn_mac_tx, 1579 .start = iwlagn_mac_start, 1580 .stop = iwlagn_mac_stop, 1581#ifdef CONFIG_PM_SLEEP 1582 .suspend = iwlagn_mac_suspend, 1583 .resume = iwlagn_mac_resume, 1584 .set_wakeup = iwlagn_mac_set_wakeup, 1585#endif 1586 .add_interface = iwlagn_mac_add_interface, 1587 .remove_interface = iwlagn_mac_remove_interface, 1588 .change_interface = iwlagn_mac_change_interface, 1589 .config = iwlagn_mac_config, 1590 .configure_filter = iwlagn_configure_filter, 1591 .set_key = iwlagn_mac_set_key, 1592 .update_tkip_key = iwlagn_mac_update_tkip_key, 1593 .set_rekey_data = iwlagn_mac_set_rekey_data, 1594 .conf_tx = iwlagn_mac_conf_tx, 1595 .bss_info_changed = iwlagn_bss_info_changed, 1596 .ampdu_action = iwlagn_mac_ampdu_action, 1597 .hw_scan = iwlagn_mac_hw_scan, 1598 .sta_notify = iwlagn_mac_sta_notify, 1599 .sta_state = iwlagn_mac_sta_state, 1600 .channel_switch = iwlagn_mac_channel_switch, 1601 .flush = iwlagn_mac_flush, 1602 .tx_last_beacon = iwlagn_mac_tx_last_beacon, 1603 .remain_on_channel = iwlagn_mac_remain_on_channel, 1604 .cancel_remain_on_channel = iwlagn_mac_cancel_remain_on_channel, 1605 .rssi_callback = iwlagn_mac_rssi_callback, 1606 CFG80211_TESTMODE_CMD(iwlagn_mac_testmode_cmd) 1607 CFG80211_TESTMODE_DUMP(iwlagn_mac_testmode_dump) 1608 .set_tim = iwlagn_mac_set_tim, 1609}; 1610 1611/* This function both allocates and initializes hw and priv. */ 1612struct ieee80211_hw *iwl_alloc_all(void) 1613{ 1614 struct iwl_priv *priv; 1615 struct iwl_op_mode *op_mode; 1616 /* mac80211 allocates memory for this device instance, including 1617 * space for this driver's private structure */ 1618 struct ieee80211_hw *hw; 1619 1620 hw = ieee80211_alloc_hw(sizeof(struct iwl_priv) + 1621 sizeof(struct iwl_op_mode), &iwlagn_hw_ops); 1622 if (!hw) 1623 goto out; 1624 1625 op_mode = hw->priv; 1626 priv = IWL_OP_MODE_GET_DVM(op_mode); 1627 priv->hw = hw; 1628 1629out: 1630 return hw; 1631} 1632