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