drivers/net/wireless/intel/iwlwifi/dvm/mac80211.c

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