iwlagn: merge station management functions
authorWey-Yi Guy <wey-yi.w.guy@intel.com>
Mon, 10 Oct 2011 14:27:12 +0000 (07:27 -0700)
committerJohn W. Linville <linville@tuxdriver.com>
Fri, 14 Oct 2011 18:48:13 +0000 (14:48 -0400)
After driver split, no need to separate station management functions
in two files, merge it

Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
17 files changed:
drivers/net/wireless/iwlwifi/Makefile
drivers/net/wireless/iwlwifi/iwl-1000.c
drivers/net/wireless/iwlwifi/iwl-2000.c
drivers/net/wireless/iwlwifi/iwl-5000.c
drivers/net/wireless/iwlwifi/iwl-6000.c
drivers/net/wireless/iwlwifi/iwl-agn-lib.c
drivers/net/wireless/iwlwifi/iwl-agn-rs.c
drivers/net/wireless/iwlwifi/iwl-agn-rxon.c
drivers/net/wireless/iwlwifi/iwl-agn-sta.c
drivers/net/wireless/iwlwifi/iwl-agn-tx.c
drivers/net/wireless/iwlwifi/iwl-agn.c
drivers/net/wireless/iwlwifi/iwl-agn.h
drivers/net/wireless/iwlwifi/iwl-core.c
drivers/net/wireless/iwlwifi/iwl-rx.c
drivers/net/wireless/iwlwifi/iwl-scan.c
drivers/net/wireless/iwlwifi/iwl-sta.c [deleted file]
drivers/net/wireless/iwlwifi/iwl-sta.h [deleted file]

index bacafa4a5f48476c3c01da7549259e32b7af9383..3dfb9df40895d812c886528d72aa27ef80276dd7 100644 (file)
@@ -6,8 +6,7 @@ iwlwifi-objs            += iwl-agn-lib.o iwl-agn-calib.o iwl-io.o
 iwlwifi-objs           += iwl-agn-tt.o iwl-agn-sta.o
 
 iwlwifi-objs           += iwl-core.o iwl-eeprom.o iwl-power.o
-iwlwifi-objs           += iwl-rx.o iwl-sta.o
-iwlwifi-objs           += iwl-scan.o iwl-led.o
+iwlwifi-objs           += iwl-rx.o iwl-scan.o iwl-led.o
 iwlwifi-objs           += iwl-agn-rxon.o
 iwlwifi-objs           += iwl-5000.o
 iwlwifi-objs           += iwl-6000.o
index dfd81debc32e412bfd107f783b077b491fb872c4..0bf6afd8e65719e9979bf96c5778de9d7ba3ecae 100644 (file)
@@ -39,7 +39,6 @@
 #include "iwl-dev.h"
 #include "iwl-core.h"
 #include "iwl-io.h"
-#include "iwl-sta.h"
 #include "iwl-agn.h"
 #include "iwl-helpers.h"
 #include "iwl-agn-hw.h"
index c7634b2d263506ca47b8bbe6f04a45a2d26d0a77..e969c5f2f4b7c009ce18dd51b23e7eef6f8009a1 100644 (file)
@@ -39,7 +39,6 @@
 #include "iwl-dev.h"
 #include "iwl-core.h"
 #include "iwl-io.h"
-#include "iwl-sta.h"
 #include "iwl-agn.h"
 #include "iwl-helpers.h"
 #include "iwl-agn-hw.h"
index e88aca5282e03f91073161fa586b456cd8f0ee4b..b85e80a71363ee764309f9c91b2c2ffc4323ef95 100644 (file)
@@ -40,7 +40,6 @@
 #include "iwl-dev.h"
 #include "iwl-core.h"
 #include "iwl-io.h"
-#include "iwl-sta.h"
 #include "iwl-helpers.h"
 #include "iwl-agn.h"
 #include "iwl-agn-hw.h"
index 4abfcf2f257c5ceacae55287340c76a772ef399c..aece578226c63172d92023baf70fff3c36672e00 100644 (file)
@@ -39,7 +39,6 @@
 #include "iwl-dev.h"
 #include "iwl-core.h"
 #include "iwl-io.h"
-#include "iwl-sta.h"
 #include "iwl-agn.h"
 #include "iwl-helpers.h"
 #include "iwl-agn-hw.h"
index d30714be515b38249028337f59d6238b7deff305..b1746f9b6648593ec86e563d2c52f9e55655dc4a 100644 (file)
@@ -38,7 +38,6 @@
 #include "iwl-helpers.h"
 #include "iwl-agn-hw.h"
 #include "iwl-agn.h"
-#include "iwl-sta.h"
 #include "iwl-trans.h"
 #include "iwl-shared.h"
 
index 353af8f995b0f8c3999e76d70a8e510f8eba3336..66118cea2af343d3f97a0b4fe52cfc7c7e093769 100644 (file)
@@ -36,7 +36,6 @@
 #include <linux/workqueue.h>
 
 #include "iwl-dev.h"
-#include "iwl-sta.h"
 #include "iwl-core.h"
 #include "iwl-agn.h"
 
index 81555223262fdea1792b8689281318821e437fa1..68bdc195e4f37dca85370cabdbfb05c96a6a227e 100644 (file)
@@ -26,7 +26,6 @@
 
 #include "iwl-dev.h"
 #include "iwl-agn.h"
-#include "iwl-sta.h"
 #include "iwl-core.h"
 #include "iwl-agn-calib.h"
 #include "iwl-helpers.h"
index c1807fa1d17199214382b58f14a331016bac1cfb..ed6283623932e2436ddc364d8429ee085df28249 100644 (file)
 
 #include "iwl-dev.h"
 #include "iwl-core.h"
-#include "iwl-sta.h"
 #include "iwl-agn.h"
 #include "iwl-trans.h"
 
+/* priv->shrd->sta_lock must be held */
+static void iwl_sta_ucode_activate(struct iwl_priv *priv, u8 sta_id)
+{
+
+       if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE))
+               IWL_ERR(priv, "ACTIVATE a non DRIVER active station id %u "
+                       "addr %pM\n",
+                       sta_id, priv->stations[sta_id].sta.sta.addr);
+
+       if (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) {
+               IWL_DEBUG_ASSOC(priv,
+                               "STA id %u addr %pM already present in uCode "
+                               "(according to driver)\n",
+                               sta_id, priv->stations[sta_id].sta.sta.addr);
+       } else {
+               priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE;
+               IWL_DEBUG_ASSOC(priv, "Added STA id %u addr %pM to uCode\n",
+                               sta_id, priv->stations[sta_id].sta.sta.addr);
+       }
+}
+
+static int iwl_process_add_sta_resp(struct iwl_priv *priv,
+                                   struct iwl_addsta_cmd *addsta,
+                                   struct iwl_rx_packet *pkt)
+{
+       u8 sta_id = addsta->sta.sta_id;
+       unsigned long flags;
+       int ret = -EIO;
+
+       if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
+               IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
+                       pkt->hdr.flags);
+               return ret;
+       }
+
+       IWL_DEBUG_INFO(priv, "Processing response for adding station %u\n",
+                      sta_id);
+
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
+
+       switch (pkt->u.add_sta.status) {
+       case ADD_STA_SUCCESS_MSK:
+               IWL_DEBUG_INFO(priv, "REPLY_ADD_STA PASSED\n");
+               iwl_sta_ucode_activate(priv, sta_id);
+               ret = 0;
+               break;
+       case ADD_STA_NO_ROOM_IN_TABLE:
+               IWL_ERR(priv, "Adding station %d failed, no room in table.\n",
+                       sta_id);
+               break;
+       case ADD_STA_NO_BLOCK_ACK_RESOURCE:
+               IWL_ERR(priv, "Adding station %d failed, no block ack "
+                       "resource.\n", sta_id);
+               break;
+       case ADD_STA_MODIFY_NON_EXIST_STA:
+               IWL_ERR(priv, "Attempting to modify non-existing station %d\n",
+                       sta_id);
+               break;
+       default:
+               IWL_DEBUG_ASSOC(priv, "Received REPLY_ADD_STA:(0x%08X)\n",
+                               pkt->u.add_sta.status);
+               break;
+       }
+
+       IWL_DEBUG_INFO(priv, "%s station id %u addr %pM\n",
+                      priv->stations[sta_id].sta.mode ==
+                      STA_CONTROL_MODIFY_MSK ?  "Modified" : "Added",
+                      sta_id, priv->stations[sta_id].sta.sta.addr);
+
+       /*
+        * XXX: The MAC address in the command buffer is often changed from
+        * the original sent to the device. That is, the MAC address
+        * written to the command buffer often is not the same MAC address
+        * read from the command buffer when the command returns. This
+        * issue has not yet been resolved and this debugging is left to
+        * observe the problem.
+        */
+       IWL_DEBUG_INFO(priv, "%s station according to cmd buffer %pM\n",
+                      priv->stations[sta_id].sta.mode ==
+                      STA_CONTROL_MODIFY_MSK ? "Modified" : "Added",
+                      addsta->sta.addr);
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+
+       return ret;
+}
+
+int iwl_add_sta_callback(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb,
+                              struct iwl_device_cmd *cmd)
+{
+       struct iwl_rx_packet *pkt = rxb_addr(rxb);
+       struct iwl_addsta_cmd *addsta =
+               (struct iwl_addsta_cmd *) cmd->payload;
+
+       return iwl_process_add_sta_resp(priv, addsta, pkt);
+}
+
+static u16 iwlagn_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data)
+{
+       u16 size = (u16)sizeof(struct iwl_addsta_cmd);
+       struct iwl_addsta_cmd *addsta = (struct iwl_addsta_cmd *)data;
+       memcpy(addsta, cmd, size);
+       /* resrved in 5000 */
+       addsta->rate_n_flags = cpu_to_le16(0);
+       return size;
+}
+
+int iwl_send_add_sta(struct iwl_priv *priv,
+                    struct iwl_addsta_cmd *sta, u8 flags)
+{
+       int ret = 0;
+       u8 data[sizeof(*sta)];
+       struct iwl_host_cmd cmd = {
+               .id = REPLY_ADD_STA,
+               .flags = flags,
+               .data = { data, },
+       };
+       u8 sta_id __maybe_unused = sta->sta.sta_id;
+
+       IWL_DEBUG_INFO(priv, "Adding sta %u (%pM) %ssynchronously\n",
+                      sta_id, sta->sta.addr, flags & CMD_ASYNC ?  "a" : "");
+
+       if (!(flags & CMD_ASYNC)) {
+               cmd.flags |= CMD_WANT_SKB;
+               might_sleep();
+       }
+
+       cmd.len[0] = iwlagn_build_addsta_hcmd(sta, data);
+       ret = iwl_trans_send_cmd(trans(priv), &cmd);
+
+       if (ret || (flags & CMD_ASYNC))
+               return ret;
+       /*else the command was successfully sent in SYNC mode, need to free
+        * the reply page */
+
+       iwl_free_pages(priv->shrd, cmd.reply_page);
+
+       if (cmd.handler_status)
+               IWL_ERR(priv, "%s - error in the CMD response %d", __func__,
+                       cmd.handler_status);
+
+       return cmd.handler_status;
+}
+
+static void iwl_set_ht_add_station(struct iwl_priv *priv, u8 index,
+                                  struct ieee80211_sta *sta,
+                                  struct iwl_rxon_context *ctx)
+{
+       struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->ht_cap;
+       __le32 sta_flags;
+       u8 mimo_ps_mode;
+
+       if (!sta || !sta_ht_inf->ht_supported)
+               goto done;
+
+       mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2;
+       IWL_DEBUG_ASSOC(priv, "spatial multiplexing power save mode: %s\n",
+                       (mimo_ps_mode == WLAN_HT_CAP_SM_PS_STATIC) ?
+                       "static" :
+                       (mimo_ps_mode == WLAN_HT_CAP_SM_PS_DYNAMIC) ?
+                       "dynamic" : "disabled");
+
+       sta_flags = priv->stations[index].sta.station_flags;
+
+       sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK);
+
+       switch (mimo_ps_mode) {
+       case WLAN_HT_CAP_SM_PS_STATIC:
+               sta_flags |= STA_FLG_MIMO_DIS_MSK;
+               break;
+       case WLAN_HT_CAP_SM_PS_DYNAMIC:
+               sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK;
+               break;
+       case WLAN_HT_CAP_SM_PS_DISABLED:
+               break;
+       default:
+               IWL_WARN(priv, "Invalid MIMO PS mode %d\n", mimo_ps_mode);
+               break;
+       }
+
+       sta_flags |= cpu_to_le32(
+             (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);
+
+       sta_flags |= cpu_to_le32(
+             (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);
+
+       if (iwl_is_ht40_tx_allowed(priv, ctx, &sta->ht_cap))
+               sta_flags |= STA_FLG_HT40_EN_MSK;
+       else
+               sta_flags &= ~STA_FLG_HT40_EN_MSK;
+
+       priv->stations[index].sta.station_flags = sta_flags;
+ done:
+       return;
+}
+
+/**
+ * iwl_prep_station - Prepare station information for addition
+ *
+ * should be called with sta_lock held
+ */
+u8 iwl_prep_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                   const u8 *addr, bool is_ap, struct ieee80211_sta *sta)
+{
+       struct iwl_station_entry *station;
+       int i;
+       u8 sta_id = IWL_INVALID_STATION;
+
+       if (is_ap)
+               sta_id = ctx->ap_sta_id;
+       else if (is_broadcast_ether_addr(addr))
+               sta_id = ctx->bcast_sta_id;
+       else
+               for (i = IWL_STA_ID; i < IWLAGN_STATION_COUNT; i++) {
+                       if (!compare_ether_addr(priv->stations[i].sta.sta.addr,
+                                               addr)) {
+                               sta_id = i;
+                               break;
+                       }
+
+                       if (!priv->stations[i].used &&
+                           sta_id == IWL_INVALID_STATION)
+                               sta_id = i;
+               }
+
+       /*
+        * These two conditions have the same outcome, but keep them
+        * separate
+        */
+       if (unlikely(sta_id == IWL_INVALID_STATION))
+               return sta_id;
+
+       /*
+        * uCode is not able to deal with multiple requests to add a
+        * station. Keep track if one is in progress so that we do not send
+        * another.
+        */
+       if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
+               IWL_DEBUG_INFO(priv, "STA %d already in process of being "
+                              "added.\n", sta_id);
+               return sta_id;
+       }
+
+       if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
+           (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) &&
+           !compare_ether_addr(priv->stations[sta_id].sta.sta.addr, addr)) {
+               IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not "
+                               "adding again.\n", sta_id, addr);
+               return sta_id;
+       }
+
+       station = &priv->stations[sta_id];
+       station->used = IWL_STA_DRIVER_ACTIVE;
+       IWL_DEBUG_ASSOC(priv, "Add STA to driver ID %d: %pM\n",
+                       sta_id, addr);
+       priv->num_stations++;
+
+       /* Set up the REPLY_ADD_STA command to send to device */
+       memset(&station->sta, 0, sizeof(struct iwl_addsta_cmd));
+       memcpy(station->sta.sta.addr, addr, ETH_ALEN);
+       station->sta.mode = 0;
+       station->sta.sta.sta_id = sta_id;
+       station->sta.station_flags = ctx->station_flags;
+       station->ctxid = ctx->ctxid;
+
+       if (sta) {
+               struct iwl_station_priv *sta_priv;
+
+               sta_priv = (void *)sta->drv_priv;
+               sta_priv->ctx = ctx;
+       }
+
+       /*
+        * OK to call unconditionally, since local stations (IBSS BSSID
+        * STA and broadcast STA) pass in a NULL sta, and mac80211
+        * doesn't allow HT IBSS.
+        */
+       iwl_set_ht_add_station(priv, sta_id, sta, ctx);
+
+       return sta_id;
+
+}
+
+#define STA_WAIT_TIMEOUT (HZ/2)
+
+/**
+ * iwl_add_station_common -
+ */
+int iwl_add_station_common(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                          const u8 *addr, bool is_ap,
+                          struct ieee80211_sta *sta, u8 *sta_id_r)
+{
+       unsigned long flags_spin;
+       int ret = 0;
+       u8 sta_id;
+       struct iwl_addsta_cmd sta_cmd;
+
+       *sta_id_r = 0;
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
+       sta_id = iwl_prep_station(priv, ctx, addr, is_ap, sta);
+       if (sta_id == IWL_INVALID_STATION) {
+               IWL_ERR(priv, "Unable to prepare station %pM for addition\n",
+                       addr);
+               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+               return -EINVAL;
+       }
+
+       /*
+        * uCode is not able to deal with multiple requests to add a
+        * station. Keep track if one is in progress so that we do not send
+        * another.
+        */
+       if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
+               IWL_DEBUG_INFO(priv, "STA %d already in process of being "
+                              "added.\n", sta_id);
+               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+               return -EEXIST;
+       }
+
+       if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
+           (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
+               IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not "
+                               "adding again.\n", sta_id, addr);
+               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+               return -EEXIST;
+       }
+
+       priv->stations[sta_id].used |= IWL_STA_UCODE_INPROGRESS;
+       memcpy(&sta_cmd, &priv->stations[sta_id].sta,
+              sizeof(struct iwl_addsta_cmd));
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+
+       /* Add station to device's station table */
+       ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
+       if (ret) {
+               spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
+               IWL_ERR(priv, "Adding station %pM failed.\n",
+                       priv->stations[sta_id].sta.sta.addr);
+               priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
+               priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
+               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+       }
+       *sta_id_r = sta_id;
+       return ret;
+}
+
+/**
+ * iwl_sta_ucode_deactivate - deactivate ucode status for a station
+ *
+ * priv->shrd->sta_lock must be held
+ */
+static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, u8 sta_id)
+{
+       /* Ucode must be active and driver must be non active */
+       if ((priv->stations[sta_id].used &
+            (IWL_STA_UCODE_ACTIVE | IWL_STA_DRIVER_ACTIVE)) !=
+             IWL_STA_UCODE_ACTIVE)
+               IWL_ERR(priv, "removed non active STA %u\n", sta_id);
+
+       priv->stations[sta_id].used &= ~IWL_STA_UCODE_ACTIVE;
+
+       memset(&priv->stations[sta_id], 0, sizeof(struct iwl_station_entry));
+       IWL_DEBUG_ASSOC(priv, "Removed STA %u\n", sta_id);
+}
+
+static int iwl_send_remove_station(struct iwl_priv *priv,
+                                  const u8 *addr, int sta_id,
+                                  bool temporary)
+{
+       struct iwl_rx_packet *pkt;
+       int ret;
+
+       unsigned long flags_spin;
+       struct iwl_rem_sta_cmd rm_sta_cmd;
+
+       struct iwl_host_cmd cmd = {
+               .id = REPLY_REMOVE_STA,
+               .len = { sizeof(struct iwl_rem_sta_cmd), },
+               .flags = CMD_SYNC,
+               .data = { &rm_sta_cmd, },
+       };
+
+       memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
+       rm_sta_cmd.num_sta = 1;
+       memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN);
+
+       cmd.flags |= CMD_WANT_SKB;
+
+       ret = iwl_trans_send_cmd(trans(priv), &cmd);
+
+       if (ret)
+               return ret;
+
+       pkt = (struct iwl_rx_packet *)cmd.reply_page;
+       if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
+               IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
+                         pkt->hdr.flags);
+               ret = -EIO;
+       }
+
+       if (!ret) {
+               switch (pkt->u.rem_sta.status) {
+               case REM_STA_SUCCESS_MSK:
+                       if (!temporary) {
+                               spin_lock_irqsave(&priv->shrd->sta_lock,
+                                       flags_spin);
+                               iwl_sta_ucode_deactivate(priv, sta_id);
+                               spin_unlock_irqrestore(&priv->shrd->sta_lock,
+                                       flags_spin);
+                       }
+                       IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n");
+                       break;
+               default:
+                       ret = -EIO;
+                       IWL_ERR(priv, "REPLY_REMOVE_STA failed\n");
+                       break;
+               }
+       }
+       iwl_free_pages(priv->shrd, cmd.reply_page);
+
+       return ret;
+}
+
+/**
+ * iwl_remove_station - Remove driver's knowledge of station.
+ */
+int iwl_remove_station(struct iwl_priv *priv, const u8 sta_id,
+                      const u8 *addr)
+{
+       unsigned long flags;
+
+       if (!iwl_is_ready(priv->shrd)) {
+               IWL_DEBUG_INFO(priv,
+                       "Unable to remove station %pM, device not ready.\n",
+                       addr);
+               /*
+                * It is typical for stations to be removed when we are
+                * going down. Return success since device will be down
+                * soon anyway
+                */
+               return 0;
+       }
+
+       IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d  %pM\n",
+                       sta_id, addr);
+
+       if (WARN_ON(sta_id == IWL_INVALID_STATION))
+               return -EINVAL;
+
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
+
+       if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
+               IWL_DEBUG_INFO(priv, "Removing %pM but non DRIVER active\n",
+                               addr);
+               goto out_err;
+       }
+
+       if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
+               IWL_DEBUG_INFO(priv, "Removing %pM but non UCODE active\n",
+                               addr);
+               goto out_err;
+       }
+
+       if (priv->stations[sta_id].used & IWL_STA_LOCAL) {
+               kfree(priv->stations[sta_id].lq);
+               priv->stations[sta_id].lq = NULL;
+       }
+
+       priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
+
+       priv->num_stations--;
+
+       if (WARN_ON(priv->num_stations < 0))
+               priv->num_stations = 0;
+
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+
+       return iwl_send_remove_station(priv, addr, sta_id, false);
+out_err:
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+       return -EINVAL;
+}
+
+/**
+ * iwl_clear_ucode_stations - clear ucode station table bits
+ *
+ * This function clears all the bits in the driver indicating
+ * which stations are active in the ucode. Call when something
+ * other than explicit station management would cause this in
+ * the ucode, e.g. unassociated RXON.
+ */
+void iwl_clear_ucode_stations(struct iwl_priv *priv,
+                             struct iwl_rxon_context *ctx)
+{
+       int i;
+       unsigned long flags_spin;
+       bool cleared = false;
+
+       IWL_DEBUG_INFO(priv, "Clearing ucode stations in driver\n");
+
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
+       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
+               if (ctx && ctx->ctxid != priv->stations[i].ctxid)
+                       continue;
+
+               if (priv->stations[i].used & IWL_STA_UCODE_ACTIVE) {
+                       IWL_DEBUG_INFO(priv,
+                               "Clearing ucode active for station %d\n", i);
+                       priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE;
+                       cleared = true;
+               }
+       }
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+
+       if (!cleared)
+               IWL_DEBUG_INFO(priv,
+                              "No active stations found to be cleared\n");
+}
+
+/**
+ * iwl_restore_stations() - Restore driver known stations to device
+ *
+ * All stations considered active by driver, but not present in ucode, is
+ * restored.
+ *
+ * Function sleeps.
+ */
+void iwl_restore_stations(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
+{
+       struct iwl_addsta_cmd sta_cmd;
+       struct iwl_link_quality_cmd lq;
+       unsigned long flags_spin;
+       int i;
+       bool found = false;
+       int ret;
+       bool send_lq;
+
+       if (!iwl_is_ready(priv->shrd)) {
+               IWL_DEBUG_INFO(priv,
+                              "Not ready yet, not restoring any stations.\n");
+               return;
+       }
+
+       IWL_DEBUG_ASSOC(priv, "Restoring all known stations ... start.\n");
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
+       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
+               if (ctx->ctxid != priv->stations[i].ctxid)
+                       continue;
+               if ((priv->stations[i].used & IWL_STA_DRIVER_ACTIVE) &&
+                           !(priv->stations[i].used & IWL_STA_UCODE_ACTIVE)) {
+                       IWL_DEBUG_ASSOC(priv, "Restoring sta %pM\n",
+                                       priv->stations[i].sta.sta.addr);
+                       priv->stations[i].sta.mode = 0;
+                       priv->stations[i].used |= IWL_STA_UCODE_INPROGRESS;
+                       found = true;
+               }
+       }
+
+       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
+               if ((priv->stations[i].used & IWL_STA_UCODE_INPROGRESS)) {
+                       memcpy(&sta_cmd, &priv->stations[i].sta,
+                              sizeof(struct iwl_addsta_cmd));
+                       send_lq = false;
+                       if (priv->stations[i].lq) {
+                               if (priv->shrd->wowlan)
+                                       iwl_sta_fill_lq(priv, ctx, i, &lq);
+                               else
+                                       memcpy(&lq, priv->stations[i].lq,
+                                              sizeof(struct iwl_link_quality_cmd));
+                               send_lq = true;
+                       }
+                       spin_unlock_irqrestore(&priv->shrd->sta_lock,
+                                              flags_spin);
+                       ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
+                       if (ret) {
+                               spin_lock_irqsave(&priv->shrd->sta_lock,
+                                                 flags_spin);
+                               IWL_ERR(priv, "Adding station %pM failed.\n",
+                                       priv->stations[i].sta.sta.addr);
+                               priv->stations[i].used &=
+                                               ~IWL_STA_DRIVER_ACTIVE;
+                               priv->stations[i].used &=
+                                               ~IWL_STA_UCODE_INPROGRESS;
+                               spin_unlock_irqrestore(&priv->shrd->sta_lock,
+                                                      flags_spin);
+                       }
+                       /*
+                        * Rate scaling has already been initialized, send
+                        * current LQ command
+                        */
+                       if (send_lq)
+                               iwl_send_lq_cmd(priv, ctx, &lq,
+                                               CMD_SYNC, true);
+                       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
+                       priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS;
+               }
+       }
+
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+       if (!found)
+               IWL_DEBUG_INFO(priv, "Restoring all known stations .... "
+                       "no stations to be restored.\n");
+       else
+               IWL_DEBUG_INFO(priv, "Restoring all known stations .... "
+                       "complete.\n");
+}
+
+void iwl_reprogram_ap_sta(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
+{
+       unsigned long flags;
+       int sta_id = ctx->ap_sta_id;
+       int ret;
+       struct iwl_addsta_cmd sta_cmd;
+       struct iwl_link_quality_cmd lq;
+       bool active;
+
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
+       if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
+               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+               return;
+       }
+
+       memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd));
+       sta_cmd.mode = 0;
+       memcpy(&lq, priv->stations[sta_id].lq, sizeof(lq));
+
+       active = priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE;
+       priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+
+       if (active) {
+               ret = iwl_send_remove_station(
+                       priv, priv->stations[sta_id].sta.sta.addr,
+                       sta_id, true);
+               if (ret)
+                       IWL_ERR(priv, "failed to remove STA %pM (%d)\n",
+                               priv->stations[sta_id].sta.sta.addr, ret);
+       }
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
+       priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE;
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+
+       ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
+       if (ret)
+               IWL_ERR(priv, "failed to re-add STA %pM (%d)\n",
+                       priv->stations[sta_id].sta.sta.addr, ret);
+       iwl_send_lq_cmd(priv, ctx, &lq, CMD_SYNC, true);
+}
+
+int iwl_get_free_ucode_key_offset(struct iwl_priv *priv)
+{
+       int i;
+
+       for (i = 0; i < priv->sta_key_max_num; i++)
+               if (!test_and_set_bit(i, &priv->ucode_key_table))
+                       return i;
+
+       return WEP_INVALID_OFFSET;
+}
+
+void iwl_dealloc_bcast_stations(struct iwl_priv *priv)
+{
+       unsigned long flags;
+       int i;
+
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
+       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
+               if (!(priv->stations[i].used & IWL_STA_BCAST))
+                       continue;
+
+               priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE;
+               priv->num_stations--;
+               if (WARN_ON(priv->num_stations < 0))
+                       priv->num_stations = 0;
+               kfree(priv->stations[i].lq);
+               priv->stations[i].lq = NULL;
+       }
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+}
+
+#ifdef CONFIG_IWLWIFI_DEBUG
+static void iwl_dump_lq_cmd(struct iwl_priv *priv,
+                          struct iwl_link_quality_cmd *lq)
+{
+       int i;
+       IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id);
+       IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n",
+                      lq->general_params.single_stream_ant_msk,
+                      lq->general_params.dual_stream_ant_msk);
+
+       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
+               IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n",
+                              i, lq->rs_table[i].rate_n_flags);
+}
+#else
+static inline void iwl_dump_lq_cmd(struct iwl_priv *priv,
+                                  struct iwl_link_quality_cmd *lq)
+{
+}
+#endif
+
+/**
+ * is_lq_table_valid() - Test one aspect of LQ cmd for validity
+ *
+ * It sometimes happens when a HT rate has been in use and we
+ * loose connectivity with AP then mac80211 will first tell us that the
+ * current channel is not HT anymore before removing the station. In such a
+ * scenario the RXON flags will be updated to indicate we are not
+ * communicating HT anymore, but the LQ command may still contain HT rates.
+ * Test for this to prevent driver from sending LQ command between the time
+ * RXON flags are updated and when LQ command is updated.
+ */
+static bool is_lq_table_valid(struct iwl_priv *priv,
+                             struct iwl_rxon_context *ctx,
+                             struct iwl_link_quality_cmd *lq)
+{
+       int i;
+
+       if (ctx->ht.enabled)
+               return true;
+
+       IWL_DEBUG_INFO(priv, "Channel %u is not an HT channel\n",
+                      ctx->active.channel);
+       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
+               if (le32_to_cpu(lq->rs_table[i].rate_n_flags) &
+                   RATE_MCS_HT_MSK) {
+                       IWL_DEBUG_INFO(priv,
+                                      "index %d of LQ expects HT channel\n",
+                                      i);
+                       return false;
+               }
+       }
+       return true;
+}
+
+/**
+ * iwl_send_lq_cmd() - Send link quality command
+ * @init: This command is sent as part of station initialization right
+ *        after station has been added.
+ *
+ * The link quality command is sent as the last step of station creation.
+ * This is the special case in which init is set and we call a callback in
+ * this case to clear the state indicating that station creation is in
+ * progress.
+ */
+int iwl_send_lq_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                   struct iwl_link_quality_cmd *lq, u8 flags, bool init)
+{
+       int ret = 0;
+       unsigned long flags_spin;
+
+       struct iwl_host_cmd cmd = {
+               .id = REPLY_TX_LINK_QUALITY_CMD,
+               .len = { sizeof(struct iwl_link_quality_cmd), },
+               .flags = flags,
+               .data = { lq, },
+       };
+
+       if (WARN_ON(lq->sta_id == IWL_INVALID_STATION))
+               return -EINVAL;
+
+
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
+       if (!(priv->stations[lq->sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
+               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+               return -EINVAL;
+       }
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+
+       iwl_dump_lq_cmd(priv, lq);
+       if (WARN_ON(init && (cmd.flags & CMD_ASYNC)))
+               return -EINVAL;
+
+       if (is_lq_table_valid(priv, ctx, lq))
+               ret = iwl_trans_send_cmd(trans(priv), &cmd);
+       else
+               ret = -EINVAL;
+
+       if (cmd.flags & CMD_ASYNC)
+               return ret;
+
+       if (init) {
+               IWL_DEBUG_INFO(priv, "init LQ command complete, "
+                              "clearing sta addition status for sta %d\n",
+                              lq->sta_id);
+               spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
+               priv->stations[lq->sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
+               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
+       }
+       return ret;
+}
+
+int iwlagn_mac_sta_remove(struct ieee80211_hw *hw,
+                      struct ieee80211_vif *vif,
+                      struct ieee80211_sta *sta)
+{
+       struct iwl_priv *priv = hw->priv;
+       struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
+       int ret;
+
+       IWL_DEBUG_MAC80211(priv, "enter: received request to remove "
+                          "station %pM\n", sta->addr);
+       mutex_lock(&priv->shrd->mutex);
+       IWL_DEBUG_INFO(priv, "proceeding to remove station %pM\n",
+                       sta->addr);
+       ret = iwl_remove_station(priv, sta_priv->sta_id, sta->addr);
+       if (ret)
+               IWL_ERR(priv, "Error removing station %pM\n",
+                       sta->addr);
+       mutex_unlock(&priv->shrd->mutex);
+       IWL_DEBUG_MAC80211(priv, "leave\n");
+
+       return ret;
+}
+
 void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
                     u8 sta_id, struct iwl_link_quality_cmd *link_cmd)
 {
@@ -77,7 +890,8 @@ void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
                        hw_params(priv).valid_tx_ant;
        }
 
-       link_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
+       link_cmd->agg_params.agg_dis_start_th =
+               LINK_QUAL_AGG_DISABLE_START_DEF;
        link_cmd->agg_params.agg_time_limit =
                cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
 
@@ -85,7 +899,8 @@ void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
 }
 
 static struct iwl_link_quality_cmd *
-iwl_sta_alloc_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx, u8 sta_id)
+iwl_sta_alloc_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                u8 sta_id)
 {
        struct iwl_link_quality_cmd *link_cmd;
 
@@ -105,7 +920,8 @@ iwl_sta_alloc_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx, u8 sta_id)
  *
  * Function sleeps.
  */
-int iwlagn_add_bssid_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+int iwlagn_add_bssid_station(struct iwl_priv *priv,
+                            struct iwl_rxon_context *ctx,
                             const u8 *addr, u8 *sta_id_r)
 {
        int ret;
@@ -132,7 +948,8 @@ int iwlagn_add_bssid_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx
        /* Set up default rate scaling table in device's station table */
        link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
        if (!link_cmd) {
-               IWL_ERR(priv, "Unable to initialize rate scaling for station %pM.\n",
+               IWL_ERR(priv,
+                       "Unable to initialize rate scaling for station %pM.\n",
                        addr);
                return -ENOMEM;
        }
@@ -224,7 +1041,8 @@ int iwl_remove_default_wep_key(struct iwl_priv *priv,
 
        memset(&ctx->wep_keys[keyconf->keyidx], 0, sizeof(ctx->wep_keys[0]));
        if (iwl_is_rfkill(priv->shrd)) {
-               IWL_DEBUG_WEP(priv, "Not sending REPLY_WEPKEY command due to RFKILL.\n");
+               IWL_DEBUG_WEP(priv,
+                       "Not sending REPLY_WEPKEY command due to RFKILL.\n");
                /* but keys in device are clear anyway so return success */
                return 0;
        }
@@ -245,7 +1063,8 @@ int iwl_set_default_wep_key(struct iwl_priv *priv,
 
        if (keyconf->keylen != WEP_KEY_LEN_128 &&
            keyconf->keylen != WEP_KEY_LEN_64) {
-               IWL_DEBUG_WEP(priv, "Bad WEP key length %d\n", keyconf->keylen);
+               IWL_DEBUG_WEP(priv,
+                             "Bad WEP key length %d\n", keyconf->keylen);
                return -EINVAL;
        }
 
index f849097cf7e66e4cd3db38385d17195b498b5e58..d7e48f2627019a89c2e08bf39a75600666d3dc6b 100644 (file)
@@ -35,7 +35,6 @@
 
 #include "iwl-dev.h"
 #include "iwl-core.h"
-#include "iwl-sta.h"
 #include "iwl-io.h"
 #include "iwl-helpers.h"
 #include "iwl-agn-hw.h"
index 6c57199b041fee050a663fd6f6461d4f51d9aa19..5a78480e452987f9a27cb1ae2c332be0527fab2a 100644 (file)
@@ -48,7 +48,6 @@
 #include "iwl-core.h"
 #include "iwl-io.h"
 #include "iwl-helpers.h"
-#include "iwl-sta.h"
 #include "iwl-agn-calib.h"
 #include "iwl-agn.h"
 #include "iwl-shared.h"
index a8df7eb596c44717b208c90d154c2a05cdb5bfaa..5b936ec1a541ecc1ecd213771f7d4e75f7960136 100644 (file)
@@ -152,10 +152,6 @@ u8 iwl_toggle_tx_ant(struct iwl_priv *priv, u8 ant_idx, u8 valid);
 void iwlagn_post_scan(struct iwl_priv *priv);
 void iwlagn_disable_roc(struct iwl_priv *priv);
 
-/* station mgmt */
-int iwlagn_manage_ibss_station(struct iwl_priv *priv,
-                              struct ieee80211_vif *vif, bool add);
-
 /* bt coex */
 void iwlagn_send_advance_bt_config(struct iwl_priv *priv);
 int iwlagn_bt_coex_profile_notif(struct iwl_priv *priv,
@@ -175,7 +171,120 @@ static inline const char *iwl_get_tx_fail_reason(u32 status) { return ""; }
 static inline const char *iwl_get_agg_tx_fail_reason(u16 status) { return ""; }
 #endif
 
+
 /* station management */
+int iwlagn_manage_ibss_station(struct iwl_priv *priv,
+                              struct ieee80211_vif *vif, bool add);
+#define IWL_STA_DRIVER_ACTIVE BIT(0) /* driver entry is active */
+#define IWL_STA_UCODE_ACTIVE  BIT(1) /* ucode entry is active */
+#define IWL_STA_UCODE_INPROGRESS  BIT(2) /* ucode entry is in process of
+                                           being activated */
+#define IWL_STA_LOCAL BIT(3) /* station state not directed by mac80211;
+                               (this is for the IBSS BSSID stations) */
+#define IWL_STA_BCAST BIT(4) /* this station is the special bcast station */
+
+
+void iwl_restore_stations(struct iwl_priv *priv, struct iwl_rxon_context *ctx);
+void iwl_clear_ucode_stations(struct iwl_priv *priv,
+                             struct iwl_rxon_context *ctx);
+void iwl_dealloc_bcast_stations(struct iwl_priv *priv);
+int iwl_get_free_ucode_key_offset(struct iwl_priv *priv);
+int iwl_send_add_sta(struct iwl_priv *priv,
+                    struct iwl_addsta_cmd *sta, u8 flags);
+int iwl_add_station_common(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                          const u8 *addr, bool is_ap,
+                          struct ieee80211_sta *sta, u8 *sta_id_r);
+int iwl_remove_station(struct iwl_priv *priv, const u8 sta_id,
+                      const u8 *addr);
+int iwlagn_mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                      struct ieee80211_sta *sta);
+
+u8 iwl_prep_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                   const u8 *addr, bool is_ap, struct ieee80211_sta *sta);
+
+void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                    u8 sta_id, struct iwl_link_quality_cmd *link_cmd);
+int iwl_send_lq_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
+                   struct iwl_link_quality_cmd *lq, u8 flags, bool init);
+void iwl_reprogram_ap_sta(struct iwl_priv *priv, struct iwl_rxon_context *ctx);
+int iwl_add_sta_callback(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb,
+                              struct iwl_device_cmd *cmd);
+
+
+/**
+ * iwl_clear_driver_stations - clear knowledge of all stations from driver
+ * @priv: iwl priv struct
+ *
+ * This is called during iwl_down() to make sure that in the case
+ * we're coming there from a hardware restart mac80211 will be
+ * able to reconfigure stations -- if we're getting there in the
+ * normal down flow then the stations will already be cleared.
+ */
+static inline void iwl_clear_driver_stations(struct iwl_priv *priv)
+{
+       unsigned long flags;
+       struct iwl_rxon_context *ctx;
+
+       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
+       memset(priv->stations, 0, sizeof(priv->stations));
+       priv->num_stations = 0;
+
+       priv->ucode_key_table = 0;
+
+       for_each_context(priv, ctx) {
+               /*
+                * Remove all key information that is not stored as part
+                * of station information since mac80211 may not have had
+                * a chance to remove all the keys. When device is
+                * reconfigured by mac80211 after an error all keys will
+                * be reconfigured.
+                */
+               memset(ctx->wep_keys, 0, sizeof(ctx->wep_keys));
+               ctx->key_mapping_keys = 0;
+       }
+
+       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
+}
+
+static inline int iwl_sta_id(struct ieee80211_sta *sta)
+{
+       if (WARN_ON(!sta))
+               return IWL_INVALID_STATION;
+
+       return ((struct iwl_station_priv *)sta->drv_priv)->sta_id;
+}
+
+/**
+ * iwl_sta_id_or_broadcast - return sta_id or broadcast sta
+ * @priv: iwl priv
+ * @context: the current context
+ * @sta: mac80211 station
+ *
+ * In certain circumstances mac80211 passes a station pointer
+ * that may be %NULL, for example during TX or key setup. In
+ * that case, we need to use the broadcast station, so this
+ * inline wraps that pattern.
+ */
+static inline int iwl_sta_id_or_broadcast(struct iwl_priv *priv,
+                                         struct iwl_rxon_context *context,
+                                         struct ieee80211_sta *sta)
+{
+       int sta_id;
+
+       if (!sta)
+               return context->bcast_sta_id;
+
+       sta_id = iwl_sta_id(sta);
+
+       /*
+        * mac80211 should not be passing a partially
+        * initialised station!
+        */
+       WARN_ON(sta_id == IWL_INVALID_STATION);
+
+       return sta_id;
+}
+
 int iwlagn_alloc_bcast_station(struct iwl_priv *priv,
                               struct iwl_rxon_context *ctx);
 int iwlagn_add_bssid_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
index f80075601439dfb8a4b68793f1090b8bdf04335c..ad66150a46cdf62df300dc4427bb70ccd30a0f1c 100644 (file)
@@ -39,7 +39,6 @@
 #include "iwl-core.h"
 #include "iwl-io.h"
 #include "iwl-power.h"
-#include "iwl-sta.h"
 #include "iwl-agn.h"
 #include "iwl-helpers.h"
 #include "iwl-shared.h"
index 2581c3cbfb50aa10efad58b6614e26a5b2b3b3e9..d406c7288ccc8912192376fb6036d0ee82c0b9fe 100644 (file)
@@ -35,7 +35,6 @@
 #include "iwl-eeprom.h"
 #include "iwl-dev.h"
 #include "iwl-core.h"
-#include "iwl-sta.h"
 #include "iwl-io.h"
 #include "iwl-helpers.h"
 #include "iwl-agn-calib.h"
index 55f1f86796a632541dd08ea18763011723144098..bb03bf8398e09da55449c7d831a4d3225b15aa27 100644 (file)
@@ -33,7 +33,6 @@
 #include "iwl-eeprom.h"
 #include "iwl-dev.h"
 #include "iwl-core.h"
-#include "iwl-sta.h"
 #include "iwl-io.h"
 #include "iwl-helpers.h"
 #include "iwl-agn.h"
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
deleted file mode 100644 (file)
index 586007e..0000000
+++ /dev/null
@@ -1,839 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * Portions of this file are derived from the ipw3945 project, as well
- * as portions of the ieee80211 subsystem header files.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-
-#include <net/mac80211.h>
-#include <linux/etherdevice.h>
-#include <linux/sched.h>
-#include <linux/lockdep.h>
-
-#include "iwl-dev.h"
-#include "iwl-core.h"
-#include "iwl-sta.h"
-#include "iwl-trans.h"
-#include "iwl-agn.h"
-
-/* priv->shrd->sta_lock must be held */
-static void iwl_sta_ucode_activate(struct iwl_priv *priv, u8 sta_id)
-{
-
-       if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE))
-               IWL_ERR(priv, "ACTIVATE a non DRIVER active station id %u addr %pM\n",
-                       sta_id, priv->stations[sta_id].sta.sta.addr);
-
-       if (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) {
-               IWL_DEBUG_ASSOC(priv,
-                               "STA id %u addr %pM already present in uCode (according to driver)\n",
-                               sta_id, priv->stations[sta_id].sta.sta.addr);
-       } else {
-               priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE;
-               IWL_DEBUG_ASSOC(priv, "Added STA id %u addr %pM to uCode\n",
-                               sta_id, priv->stations[sta_id].sta.sta.addr);
-       }
-}
-
-static int iwl_process_add_sta_resp(struct iwl_priv *priv,
-                                   struct iwl_addsta_cmd *addsta,
-                                   struct iwl_rx_packet *pkt)
-{
-       u8 sta_id = addsta->sta.sta_id;
-       unsigned long flags;
-       int ret = -EIO;
-
-       if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
-               IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
-                       pkt->hdr.flags);
-               return ret;
-       }
-
-       IWL_DEBUG_INFO(priv, "Processing response for adding station %u\n",
-                      sta_id);
-
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
-
-       switch (pkt->u.add_sta.status) {
-       case ADD_STA_SUCCESS_MSK:
-               IWL_DEBUG_INFO(priv, "REPLY_ADD_STA PASSED\n");
-               iwl_sta_ucode_activate(priv, sta_id);
-               ret = 0;
-               break;
-       case ADD_STA_NO_ROOM_IN_TABLE:
-               IWL_ERR(priv, "Adding station %d failed, no room in table.\n",
-                       sta_id);
-               break;
-       case ADD_STA_NO_BLOCK_ACK_RESOURCE:
-               IWL_ERR(priv, "Adding station %d failed, no block ack resource.\n",
-                       sta_id);
-               break;
-       case ADD_STA_MODIFY_NON_EXIST_STA:
-               IWL_ERR(priv, "Attempting to modify non-existing station %d\n",
-                       sta_id);
-               break;
-       default:
-               IWL_DEBUG_ASSOC(priv, "Received REPLY_ADD_STA:(0x%08X)\n",
-                               pkt->u.add_sta.status);
-               break;
-       }
-
-       IWL_DEBUG_INFO(priv, "%s station id %u addr %pM\n",
-                      priv->stations[sta_id].sta.mode ==
-                      STA_CONTROL_MODIFY_MSK ?  "Modified" : "Added",
-                      sta_id, priv->stations[sta_id].sta.sta.addr);
-
-       /*
-        * XXX: The MAC address in the command buffer is often changed from
-        * the original sent to the device. That is, the MAC address
-        * written to the command buffer often is not the same MAC address
-        * read from the command buffer when the command returns. This
-        * issue has not yet been resolved and this debugging is left to
-        * observe the problem.
-        */
-       IWL_DEBUG_INFO(priv, "%s station according to cmd buffer %pM\n",
-                      priv->stations[sta_id].sta.mode ==
-                      STA_CONTROL_MODIFY_MSK ? "Modified" : "Added",
-                      addsta->sta.addr);
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-
-       return ret;
-}
-
-int iwl_add_sta_callback(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb,
-                              struct iwl_device_cmd *cmd)
-{
-       struct iwl_rx_packet *pkt = rxb_addr(rxb);
-       struct iwl_addsta_cmd *addsta =
-               (struct iwl_addsta_cmd *) cmd->payload;
-
-       return iwl_process_add_sta_resp(priv, addsta, pkt);
-}
-
-static u16 iwlagn_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data)
-{
-       u16 size = (u16)sizeof(struct iwl_addsta_cmd);
-       struct iwl_addsta_cmd *addsta = (struct iwl_addsta_cmd *)data;
-       memcpy(addsta, cmd, size);
-       /* resrved in 5000 */
-       addsta->rate_n_flags = cpu_to_le16(0);
-       return size;
-}
-
-int iwl_send_add_sta(struct iwl_priv *priv,
-                    struct iwl_addsta_cmd *sta, u8 flags)
-{
-       int ret = 0;
-       u8 data[sizeof(*sta)];
-       struct iwl_host_cmd cmd = {
-               .id = REPLY_ADD_STA,
-               .flags = flags,
-               .data = { data, },
-       };
-       u8 sta_id __maybe_unused = sta->sta.sta_id;
-
-       IWL_DEBUG_INFO(priv, "Adding sta %u (%pM) %ssynchronously\n",
-                      sta_id, sta->sta.addr, flags & CMD_ASYNC ?  "a" : "");
-
-       if (!(flags & CMD_ASYNC)) {
-               cmd.flags |= CMD_WANT_SKB;
-               might_sleep();
-       }
-
-       cmd.len[0] = iwlagn_build_addsta_hcmd(sta, data);
-       ret = iwl_trans_send_cmd(trans(priv), &cmd);
-
-       if (ret || (flags & CMD_ASYNC))
-               return ret;
-       /*else the command was successfully sent in SYNC mode, need to free
-        * the reply page */
-
-       iwl_free_pages(priv->shrd, cmd.reply_page);
-
-       if (cmd.handler_status)
-               IWL_ERR(priv, "%s - error in the CMD response %d", __func__,
-                       cmd.handler_status);
-
-       return cmd.handler_status;
-}
-
-static void iwl_set_ht_add_station(struct iwl_priv *priv, u8 index,
-                                  struct ieee80211_sta *sta,
-                                  struct iwl_rxon_context *ctx)
-{
-       struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->ht_cap;
-       __le32 sta_flags;
-       u8 mimo_ps_mode;
-
-       if (!sta || !sta_ht_inf->ht_supported)
-               goto done;
-
-       mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2;
-       IWL_DEBUG_ASSOC(priv, "spatial multiplexing power save mode: %s\n",
-                       (mimo_ps_mode == WLAN_HT_CAP_SM_PS_STATIC) ?
-                       "static" :
-                       (mimo_ps_mode == WLAN_HT_CAP_SM_PS_DYNAMIC) ?
-                       "dynamic" : "disabled");
-
-       sta_flags = priv->stations[index].sta.station_flags;
-
-       sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK);
-
-       switch (mimo_ps_mode) {
-       case WLAN_HT_CAP_SM_PS_STATIC:
-               sta_flags |= STA_FLG_MIMO_DIS_MSK;
-               break;
-       case WLAN_HT_CAP_SM_PS_DYNAMIC:
-               sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK;
-               break;
-       case WLAN_HT_CAP_SM_PS_DISABLED:
-               break;
-       default:
-               IWL_WARN(priv, "Invalid MIMO PS mode %d\n", mimo_ps_mode);
-               break;
-       }
-
-       sta_flags |= cpu_to_le32(
-             (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);
-
-       sta_flags |= cpu_to_le32(
-             (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);
-
-       if (iwl_is_ht40_tx_allowed(priv, ctx, &sta->ht_cap))
-               sta_flags |= STA_FLG_HT40_EN_MSK;
-       else
-               sta_flags &= ~STA_FLG_HT40_EN_MSK;
-
-       priv->stations[index].sta.station_flags = sta_flags;
- done:
-       return;
-}
-
-/**
- * iwl_prep_station - Prepare station information for addition
- *
- * should be called with sta_lock held
- */
-u8 iwl_prep_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
-                   const u8 *addr, bool is_ap, struct ieee80211_sta *sta)
-{
-       struct iwl_station_entry *station;
-       int i;
-       u8 sta_id = IWL_INVALID_STATION;
-
-       if (is_ap)
-               sta_id = ctx->ap_sta_id;
-       else if (is_broadcast_ether_addr(addr))
-               sta_id = ctx->bcast_sta_id;
-       else
-               for (i = IWL_STA_ID; i < IWLAGN_STATION_COUNT; i++) {
-                       if (!compare_ether_addr(priv->stations[i].sta.sta.addr,
-                                               addr)) {
-                               sta_id = i;
-                               break;
-                       }
-
-                       if (!priv->stations[i].used &&
-                           sta_id == IWL_INVALID_STATION)
-                               sta_id = i;
-               }
-
-       /*
-        * These two conditions have the same outcome, but keep them
-        * separate
-        */
-       if (unlikely(sta_id == IWL_INVALID_STATION))
-               return sta_id;
-
-       /*
-        * uCode is not able to deal with multiple requests to add a
-        * station. Keep track if one is in progress so that we do not send
-        * another.
-        */
-       if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
-               IWL_DEBUG_INFO(priv, "STA %d already in process of being added.\n",
-                               sta_id);
-               return sta_id;
-       }
-
-       if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
-           (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) &&
-           !compare_ether_addr(priv->stations[sta_id].sta.sta.addr, addr)) {
-               IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not adding again.\n",
-                               sta_id, addr);
-               return sta_id;
-       }
-
-       station = &priv->stations[sta_id];
-       station->used = IWL_STA_DRIVER_ACTIVE;
-       IWL_DEBUG_ASSOC(priv, "Add STA to driver ID %d: %pM\n",
-                       sta_id, addr);
-       priv->num_stations++;
-
-       /* Set up the REPLY_ADD_STA command to send to device */
-       memset(&station->sta, 0, sizeof(struct iwl_addsta_cmd));
-       memcpy(station->sta.sta.addr, addr, ETH_ALEN);
-       station->sta.mode = 0;
-       station->sta.sta.sta_id = sta_id;
-       station->sta.station_flags = ctx->station_flags;
-       station->ctxid = ctx->ctxid;
-
-       if (sta) {
-               struct iwl_station_priv *sta_priv;
-
-               sta_priv = (void *)sta->drv_priv;
-               sta_priv->ctx = ctx;
-       }
-
-       /*
-        * OK to call unconditionally, since local stations (IBSS BSSID
-        * STA and broadcast STA) pass in a NULL sta, and mac80211
-        * doesn't allow HT IBSS.
-        */
-       iwl_set_ht_add_station(priv, sta_id, sta, ctx);
-
-       return sta_id;
-
-}
-
-#define STA_WAIT_TIMEOUT (HZ/2)
-
-/**
- * iwl_add_station_common -
- */
-int iwl_add_station_common(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
-                          const u8 *addr, bool is_ap,
-                          struct ieee80211_sta *sta, u8 *sta_id_r)
-{
-       unsigned long flags_spin;
-       int ret = 0;
-       u8 sta_id;
-       struct iwl_addsta_cmd sta_cmd;
-
-       *sta_id_r = 0;
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
-       sta_id = iwl_prep_station(priv, ctx, addr, is_ap, sta);
-       if (sta_id == IWL_INVALID_STATION) {
-               IWL_ERR(priv, "Unable to prepare station %pM for addition\n",
-                       addr);
-               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-               return -EINVAL;
-       }
-
-       /*
-        * uCode is not able to deal with multiple requests to add a
-        * station. Keep track if one is in progress so that we do not send
-        * another.
-        */
-       if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
-               IWL_DEBUG_INFO(priv, "STA %d already in process of being added.\n",
-                              sta_id);
-               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-               return -EEXIST;
-       }
-
-       if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
-           (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
-               IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not adding again.\n",
-                               sta_id, addr);
-               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-               return -EEXIST;
-       }
-
-       priv->stations[sta_id].used |= IWL_STA_UCODE_INPROGRESS;
-       memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-
-       /* Add station to device's station table */
-       ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
-       if (ret) {
-               spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
-               IWL_ERR(priv, "Adding station %pM failed.\n",
-                       priv->stations[sta_id].sta.sta.addr);
-               priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
-               priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
-               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-       }
-       *sta_id_r = sta_id;
-       return ret;
-}
-
-/**
- * iwl_sta_ucode_deactivate - deactivate ucode status for a station
- *
- * priv->shrd->sta_lock must be held
- */
-static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, u8 sta_id)
-{
-       /* Ucode must be active and driver must be non active */
-       if ((priv->stations[sta_id].used &
-            (IWL_STA_UCODE_ACTIVE | IWL_STA_DRIVER_ACTIVE)) != IWL_STA_UCODE_ACTIVE)
-               IWL_ERR(priv, "removed non active STA %u\n", sta_id);
-
-       priv->stations[sta_id].used &= ~IWL_STA_UCODE_ACTIVE;
-
-       memset(&priv->stations[sta_id], 0, sizeof(struct iwl_station_entry));
-       IWL_DEBUG_ASSOC(priv, "Removed STA %u\n", sta_id);
-}
-
-static int iwl_send_remove_station(struct iwl_priv *priv,
-                                  const u8 *addr, int sta_id,
-                                  bool temporary)
-{
-       struct iwl_rx_packet *pkt;
-       int ret;
-
-       unsigned long flags_spin;
-       struct iwl_rem_sta_cmd rm_sta_cmd;
-
-       struct iwl_host_cmd cmd = {
-               .id = REPLY_REMOVE_STA,
-               .len = { sizeof(struct iwl_rem_sta_cmd), },
-               .flags = CMD_SYNC,
-               .data = { &rm_sta_cmd, },
-       };
-
-       memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
-       rm_sta_cmd.num_sta = 1;
-       memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN);
-
-       cmd.flags |= CMD_WANT_SKB;
-
-       ret = iwl_trans_send_cmd(trans(priv), &cmd);
-
-       if (ret)
-               return ret;
-
-       pkt = (struct iwl_rx_packet *)cmd.reply_page;
-       if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
-               IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
-                         pkt->hdr.flags);
-               ret = -EIO;
-       }
-
-       if (!ret) {
-               switch (pkt->u.rem_sta.status) {
-               case REM_STA_SUCCESS_MSK:
-                       if (!temporary) {
-                               spin_lock_irqsave(&priv->shrd->sta_lock,
-                                       flags_spin);
-                               iwl_sta_ucode_deactivate(priv, sta_id);
-                               spin_unlock_irqrestore(&priv->shrd->sta_lock,
-                                       flags_spin);
-                       }
-                       IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n");
-                       break;
-               default:
-                       ret = -EIO;
-                       IWL_ERR(priv, "REPLY_REMOVE_STA failed\n");
-                       break;
-               }
-       }
-       iwl_free_pages(priv->shrd, cmd.reply_page);
-
-       return ret;
-}
-
-/**
- * iwl_remove_station - Remove driver's knowledge of station.
- */
-int iwl_remove_station(struct iwl_priv *priv, const u8 sta_id,
-                      const u8 *addr)
-{
-       unsigned long flags;
-
-       if (!iwl_is_ready(priv->shrd)) {
-               IWL_DEBUG_INFO(priv,
-                       "Unable to remove station %pM, device not ready.\n",
-                       addr);
-               /*
-                * It is typical for stations to be removed when we are
-                * going down. Return success since device will be down
-                * soon anyway
-                */
-               return 0;
-       }
-
-       IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d  %pM\n",
-                       sta_id, addr);
-
-       if (WARN_ON(sta_id == IWL_INVALID_STATION))
-               return -EINVAL;
-
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
-
-       if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
-               IWL_DEBUG_INFO(priv, "Removing %pM but non DRIVER active\n",
-                               addr);
-               goto out_err;
-       }
-
-       if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
-               IWL_DEBUG_INFO(priv, "Removing %pM but non UCODE active\n",
-                               addr);
-               goto out_err;
-       }
-
-       if (priv->stations[sta_id].used & IWL_STA_LOCAL) {
-               kfree(priv->stations[sta_id].lq);
-               priv->stations[sta_id].lq = NULL;
-       }
-
-       priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
-
-       priv->num_stations--;
-
-       if (WARN_ON(priv->num_stations < 0))
-               priv->num_stations = 0;
-
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-
-       return iwl_send_remove_station(priv, addr, sta_id, false);
-out_err:
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-       return -EINVAL;
-}
-
-/**
- * iwl_clear_ucode_stations - clear ucode station table bits
- *
- * This function clears all the bits in the driver indicating
- * which stations are active in the ucode. Call when something
- * other than explicit station management would cause this in
- * the ucode, e.g. unassociated RXON.
- */
-void iwl_clear_ucode_stations(struct iwl_priv *priv,
-                             struct iwl_rxon_context *ctx)
-{
-       int i;
-       unsigned long flags_spin;
-       bool cleared = false;
-
-       IWL_DEBUG_INFO(priv, "Clearing ucode stations in driver\n");
-
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
-       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
-               if (ctx && ctx->ctxid != priv->stations[i].ctxid)
-                       continue;
-
-               if (priv->stations[i].used & IWL_STA_UCODE_ACTIVE) {
-                       IWL_DEBUG_INFO(priv, "Clearing ucode active for station %d\n", i);
-                       priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE;
-                       cleared = true;
-               }
-       }
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-
-       if (!cleared)
-               IWL_DEBUG_INFO(priv, "No active stations found to be cleared\n");
-}
-
-/**
- * iwl_restore_stations() - Restore driver known stations to device
- *
- * All stations considered active by driver, but not present in ucode, is
- * restored.
- *
- * Function sleeps.
- */
-void iwl_restore_stations(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
-{
-       struct iwl_addsta_cmd sta_cmd;
-       struct iwl_link_quality_cmd lq;
-       unsigned long flags_spin;
-       int i;
-       bool found = false;
-       int ret;
-       bool send_lq;
-
-       if (!iwl_is_ready(priv->shrd)) {
-               IWL_DEBUG_INFO(priv, "Not ready yet, not restoring any stations.\n");
-               return;
-       }
-
-       IWL_DEBUG_ASSOC(priv, "Restoring all known stations ... start.\n");
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
-       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
-               if (ctx->ctxid != priv->stations[i].ctxid)
-                       continue;
-               if ((priv->stations[i].used & IWL_STA_DRIVER_ACTIVE) &&
-                           !(priv->stations[i].used & IWL_STA_UCODE_ACTIVE)) {
-                       IWL_DEBUG_ASSOC(priv, "Restoring sta %pM\n",
-                                       priv->stations[i].sta.sta.addr);
-                       priv->stations[i].sta.mode = 0;
-                       priv->stations[i].used |= IWL_STA_UCODE_INPROGRESS;
-                       found = true;
-               }
-       }
-
-       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
-               if ((priv->stations[i].used & IWL_STA_UCODE_INPROGRESS)) {
-                       memcpy(&sta_cmd, &priv->stations[i].sta,
-                              sizeof(struct iwl_addsta_cmd));
-                       send_lq = false;
-                       if (priv->stations[i].lq) {
-                               if (priv->shrd->wowlan)
-                                       iwl_sta_fill_lq(priv, ctx, i, &lq);
-                               else
-                                       memcpy(&lq, priv->stations[i].lq,
-                                              sizeof(struct iwl_link_quality_cmd));
-                               send_lq = true;
-                       }
-                       spin_unlock_irqrestore(&priv->shrd->sta_lock,
-                                              flags_spin);
-                       ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
-                       if (ret) {
-                               spin_lock_irqsave(&priv->shrd->sta_lock,
-                                                 flags_spin);
-                               IWL_ERR(priv, "Adding station %pM failed.\n",
-                                       priv->stations[i].sta.sta.addr);
-                               priv->stations[i].used &= ~IWL_STA_DRIVER_ACTIVE;
-                               priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS;
-                               spin_unlock_irqrestore(&priv->shrd->sta_lock,
-                                                      flags_spin);
-                       }
-                       /*
-                        * Rate scaling has already been initialized, send
-                        * current LQ command
-                        */
-                       if (send_lq)
-                               iwl_send_lq_cmd(priv, ctx, &lq, CMD_SYNC, true);
-                       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
-                       priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS;
-               }
-       }
-
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-       if (!found)
-               IWL_DEBUG_INFO(priv, "Restoring all known stations .... no stations to be restored.\n");
-       else
-               IWL_DEBUG_INFO(priv, "Restoring all known stations .... complete.\n");
-}
-
-void iwl_reprogram_ap_sta(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
-{
-       unsigned long flags;
-       int sta_id = ctx->ap_sta_id;
-       int ret;
-       struct iwl_addsta_cmd sta_cmd;
-       struct iwl_link_quality_cmd lq;
-       bool active;
-
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
-       if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
-               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-               return;
-       }
-
-       memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd));
-       sta_cmd.mode = 0;
-       memcpy(&lq, priv->stations[sta_id].lq, sizeof(lq));
-
-       active = priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE;
-       priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-
-       if (active) {
-               ret = iwl_send_remove_station(
-                       priv, priv->stations[sta_id].sta.sta.addr,
-                       sta_id, true);
-               if (ret)
-                       IWL_ERR(priv, "failed to remove STA %pM (%d)\n",
-                               priv->stations[sta_id].sta.sta.addr, ret);
-       }
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
-       priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE;
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-
-       ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
-       if (ret)
-               IWL_ERR(priv, "failed to re-add STA %pM (%d)\n",
-                       priv->stations[sta_id].sta.sta.addr, ret);
-       iwl_send_lq_cmd(priv, ctx, &lq, CMD_SYNC, true);
-}
-
-int iwl_get_free_ucode_key_offset(struct iwl_priv *priv)
-{
-       int i;
-
-       for (i = 0; i < priv->sta_key_max_num; i++)
-               if (!test_and_set_bit(i, &priv->ucode_key_table))
-                       return i;
-
-       return WEP_INVALID_OFFSET;
-}
-
-void iwl_dealloc_bcast_stations(struct iwl_priv *priv)
-{
-       unsigned long flags;
-       int i;
-
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
-       for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
-               if (!(priv->stations[i].used & IWL_STA_BCAST))
-                       continue;
-
-               priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE;
-               priv->num_stations--;
-               if (WARN_ON(priv->num_stations < 0))
-                       priv->num_stations = 0;
-               kfree(priv->stations[i].lq);
-               priv->stations[i].lq = NULL;
-       }
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-}
-
-#ifdef CONFIG_IWLWIFI_DEBUG
-static void iwl_dump_lq_cmd(struct iwl_priv *priv,
-                          struct iwl_link_quality_cmd *lq)
-{
-       int i;
-       IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id);
-       IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n",
-                      lq->general_params.single_stream_ant_msk,
-                      lq->general_params.dual_stream_ant_msk);
-
-       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
-               IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n",
-                              i, lq->rs_table[i].rate_n_flags);
-}
-#else
-static inline void iwl_dump_lq_cmd(struct iwl_priv *priv,
-                                  struct iwl_link_quality_cmd *lq)
-{
-}
-#endif
-
-/**
- * is_lq_table_valid() - Test one aspect of LQ cmd for validity
- *
- * It sometimes happens when a HT rate has been in use and we
- * loose connectivity with AP then mac80211 will first tell us that the
- * current channel is not HT anymore before removing the station. In such a
- * scenario the RXON flags will be updated to indicate we are not
- * communicating HT anymore, but the LQ command may still contain HT rates.
- * Test for this to prevent driver from sending LQ command between the time
- * RXON flags are updated and when LQ command is updated.
- */
-static bool is_lq_table_valid(struct iwl_priv *priv,
-                             struct iwl_rxon_context *ctx,
-                             struct iwl_link_quality_cmd *lq)
-{
-       int i;
-
-       if (ctx->ht.enabled)
-               return true;
-
-       IWL_DEBUG_INFO(priv, "Channel %u is not an HT channel\n",
-                      ctx->active.channel);
-       for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
-               if (le32_to_cpu(lq->rs_table[i].rate_n_flags) & RATE_MCS_HT_MSK) {
-                       IWL_DEBUG_INFO(priv,
-                                      "index %d of LQ expects HT channel\n",
-                                      i);
-                       return false;
-               }
-       }
-       return true;
-}
-
-/**
- * iwl_send_lq_cmd() - Send link quality command
- * @init: This command is sent as part of station initialization right
- *        after station has been added.
- *
- * The link quality command is sent as the last step of station creation.
- * This is the special case in which init is set and we call a callback in
- * this case to clear the state indicating that station creation is in
- * progress.
- */
-int iwl_send_lq_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
-                   struct iwl_link_quality_cmd *lq, u8 flags, bool init)
-{
-       int ret = 0;
-       unsigned long flags_spin;
-
-       struct iwl_host_cmd cmd = {
-               .id = REPLY_TX_LINK_QUALITY_CMD,
-               .len = { sizeof(struct iwl_link_quality_cmd), },
-               .flags = flags,
-               .data = { lq, },
-       };
-
-       if (WARN_ON(lq->sta_id == IWL_INVALID_STATION))
-               return -EINVAL;
-
-
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
-       if (!(priv->stations[lq->sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
-               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-               return -EINVAL;
-       }
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-
-       iwl_dump_lq_cmd(priv, lq);
-       if (WARN_ON(init && (cmd.flags & CMD_ASYNC)))
-               return -EINVAL;
-
-       if (is_lq_table_valid(priv, ctx, lq))
-               ret = iwl_trans_send_cmd(trans(priv), &cmd);
-       else
-               ret = -EINVAL;
-
-       if (cmd.flags & CMD_ASYNC)
-               return ret;
-
-       if (init) {
-               IWL_DEBUG_INFO(priv, "init LQ command complete, clearing sta addition status for sta %d\n",
-                              lq->sta_id);
-               spin_lock_irqsave(&priv->shrd->sta_lock, flags_spin);
-               priv->stations[lq->sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
-               spin_unlock_irqrestore(&priv->shrd->sta_lock, flags_spin);
-       }
-       return ret;
-}
-
-int iwlagn_mac_sta_remove(struct ieee80211_hw *hw,
-                      struct ieee80211_vif *vif,
-                      struct ieee80211_sta *sta)
-{
-       struct iwl_priv *priv = hw->priv;
-       struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
-       int ret;
-
-       IWL_DEBUG_MAC80211(priv, "enter: received request to remove "
-                          "station %pM\n", sta->addr);
-       mutex_lock(&priv->shrd->mutex);
-       IWL_DEBUG_INFO(priv, "proceeding to remove station %pM\n",
-                       sta->addr);
-       ret = iwl_remove_station(priv, sta_priv->sta_id, sta->addr);
-       if (ret)
-               IWL_ERR(priv, "Error removing station %pM\n",
-                       sta->addr);
-       mutex_unlock(&priv->shrd->mutex);
-       IWL_DEBUG_MAC80211(priv, "leave\n");
-
-       return ret;
-}
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.h b/drivers/net/wireless/iwlwifi/iwl-sta.h
deleted file mode 100644 (file)
index 73b4af2..0000000
+++ /dev/null
@@ -1,143 +0,0 @@
-/******************************************************************************
- *
- * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
- *
- * Portions of this file are derived from the ipw3945 project, as well
- * as portions of the ieee80211 subsystem header files.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of version 2 of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
- *
- * The full GNU General Public License is included in this distribution in the
- * file called LICENSE.
- *
- * Contact Information:
- *  Intel Linux Wireless <ilw@linux.intel.com>
- * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
- *
- *****************************************************************************/
-#ifndef __iwl_sta_h__
-#define __iwl_sta_h__
-
-#include "iwl-dev.h"
-
-#define IWL_STA_DRIVER_ACTIVE BIT(0) /* driver entry is active */
-#define IWL_STA_UCODE_ACTIVE  BIT(1) /* ucode entry is active */
-#define IWL_STA_UCODE_INPROGRESS  BIT(2) /* ucode entry is in process of
-                                           being activated */
-#define IWL_STA_LOCAL BIT(3) /* station state not directed by mac80211;
-                               (this is for the IBSS BSSID stations) */
-#define IWL_STA_BCAST BIT(4) /* this station is the special bcast station */
-
-
-void iwl_restore_stations(struct iwl_priv *priv, struct iwl_rxon_context *ctx);
-void iwl_clear_ucode_stations(struct iwl_priv *priv,
-                             struct iwl_rxon_context *ctx);
-void iwl_dealloc_bcast_stations(struct iwl_priv *priv);
-int iwl_get_free_ucode_key_offset(struct iwl_priv *priv);
-int iwl_send_add_sta(struct iwl_priv *priv,
-                    struct iwl_addsta_cmd *sta, u8 flags);
-int iwl_add_station_common(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
-                          const u8 *addr, bool is_ap,
-                          struct ieee80211_sta *sta, u8 *sta_id_r);
-int iwl_remove_station(struct iwl_priv *priv, const u8 sta_id,
-                      const u8 *addr);
-int iwlagn_mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
-                      struct ieee80211_sta *sta);
-
-u8 iwl_prep_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
-                   const u8 *addr, bool is_ap, struct ieee80211_sta *sta);
-
-void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
-                    u8 sta_id, struct iwl_link_quality_cmd *link_cmd);
-int iwl_send_lq_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
-                   struct iwl_link_quality_cmd *lq, u8 flags, bool init);
-void iwl_reprogram_ap_sta(struct iwl_priv *priv, struct iwl_rxon_context *ctx);
-int iwl_add_sta_callback(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb,
-                              struct iwl_device_cmd *cmd);
-
-
-/**
- * iwl_clear_driver_stations - clear knowledge of all stations from driver
- * @priv: iwl priv struct
- *
- * This is called during iwl_down() to make sure that in the case
- * we're coming there from a hardware restart mac80211 will be
- * able to reconfigure stations -- if we're getting there in the
- * normal down flow then the stations will already be cleared.
- */
-static inline void iwl_clear_driver_stations(struct iwl_priv *priv)
-{
-       unsigned long flags;
-       struct iwl_rxon_context *ctx;
-
-       spin_lock_irqsave(&priv->shrd->sta_lock, flags);
-       memset(priv->stations, 0, sizeof(priv->stations));
-       priv->num_stations = 0;
-
-       priv->ucode_key_table = 0;
-
-       for_each_context(priv, ctx) {
-               /*
-                * Remove all key information that is not stored as part
-                * of station information since mac80211 may not have had
-                * a chance to remove all the keys. When device is
-                * reconfigured by mac80211 after an error all keys will
-                * be reconfigured.
-                */
-               memset(ctx->wep_keys, 0, sizeof(ctx->wep_keys));
-               ctx->key_mapping_keys = 0;
-       }
-
-       spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
-}
-
-static inline int iwl_sta_id(struct ieee80211_sta *sta)
-{
-       if (WARN_ON(!sta))
-               return IWL_INVALID_STATION;
-
-       return ((struct iwl_station_priv *)sta->drv_priv)->sta_id;
-}
-
-/**
- * iwl_sta_id_or_broadcast - return sta_id or broadcast sta
- * @priv: iwl priv
- * @context: the current context
- * @sta: mac80211 station
- *
- * In certain circumstances mac80211 passes a station pointer
- * that may be %NULL, for example during TX or key setup. In
- * that case, we need to use the broadcast station, so this
- * inline wraps that pattern.
- */
-static inline int iwl_sta_id_or_broadcast(struct iwl_priv *priv,
-                                         struct iwl_rxon_context *context,
-                                         struct ieee80211_sta *sta)
-{
-       int sta_id;
-
-       if (!sta)
-               return context->bcast_sta_id;
-
-       sta_id = iwl_sta_id(sta);
-
-       /*
-        * mac80211 should not be passing a partially
-        * initialised station!
-        */
-       WARN_ON(sta_id == IWL_INVALID_STATION);
-
-       return sta_id;
-}
-#endif /* __iwl_sta_h__ */