iwl3945: Getting rid of the *39_rxon iwl_priv fields

The iwl_rxon_cmd is really just a iwl3945_rxon_cmd structure extension.
So, we can use the *_rxon fields from iwl_priv instead of the 3945 specific
ones (*39_rxon). We have to then be careful when submitting REPLY_RXON host
commands, since the command length as to be set according to the HW. As
another precaution the reserved4 and reserved5 fields are cleared before being
sent to the 3945.

With the *39_rxon removal, a lot of duplicated code can be removed from the
3945 code base.

Signed-off-by: Samuel Ortiz <samuel.ortiz@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 434 insertions, 0 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index 21f386568c9c..4f2b88c59c71 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -28,6 +28,7 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/etherdevice.h>
 #include <net/mac80211.h>
 
 #include "iwl-eeprom.h"
@@ -403,6 +404,7 @@ static void iwlcore_init_hw_rates(struct iwl_priv *priv,
         }
 }
 
+
 /**
  * iwlcore_init_geos - Initialize mac80211's geo/channel info based from eeprom
  */
@@ -586,6 +588,167 @@ u8 iwl_is_fat_tx_allowed(struct iwl_priv *priv,
 }
 EXPORT_SYMBOL(iwl_is_fat_tx_allowed);
 
+void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
+{
+        struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
+
+        if (hw_decrypt)
+                rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
+        else
+                rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
+
+}
+EXPORT_SYMBOL(iwl_set_rxon_hwcrypto);
+
+/**
+ * iwl_check_rxon_cmd - validate RXON structure is valid
+ *
+ * NOTE:  This is really only useful during development and can eventually
+ * be #ifdef'd out once the driver is stable and folks aren't actively
+ * making changes
+ */
+int iwl_check_rxon_cmd(struct iwl_priv *priv)
+{
+        int error = 0;
+        int counter = 1;
+        struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
+
+        if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
+                error |= le32_to_cpu(rxon->flags &
+                                (RXON_FLG_TGJ_NARROW_BAND_MSK |
+                                 RXON_FLG_RADAR_DETECT_MSK));
+                if (error)
+                        IWL_WARN(priv, "check 24G fields %d | %d\n",
+                                    counter++, error);
+        } else {
+                error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
+                                0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
+                if (error)
+                        IWL_WARN(priv, "check 52 fields %d | %d\n",
+                                    counter++, error);
+                error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
+                if (error)
+                        IWL_WARN(priv, "check 52 CCK %d | %d\n",
+                                    counter++, error);
+        }
+        error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
+        if (error)
+                IWL_WARN(priv, "check mac addr %d | %d\n", counter++, error);
+
+        /* make sure basic rates 6Mbps and 1Mbps are supported */
+        error |= (((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0) &&
+                  ((rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0));
+        if (error)
+                IWL_WARN(priv, "check basic rate %d | %d\n", counter++, error);
+
+        error |= (le16_to_cpu(rxon->assoc_id) > 2007);
+        if (error)
+                IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);
+
+        error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
+                        == (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
+        if (error)
+                IWL_WARN(priv, "check CCK and short slot %d | %d\n",
+                            counter++, error);
+
+        error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK))
+                        == (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK));
+        if (error)
+                IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
+                            counter++, error);
+
+        error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
+                        RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
+        if (error)
+                IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
+                            counter++, error);
+
+        if (error)
+                IWL_WARN(priv, "Tuning to channel %d\n",
+                            le16_to_cpu(rxon->channel));
+
+        if (error) {
+                IWL_ERR(priv, "Not a valid iwl_rxon_assoc_cmd field values\n");
+                return -1;
+        }
+        return 0;
+}
+EXPORT_SYMBOL(iwl_check_rxon_cmd);
+
+/**
+ * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
+ * @priv: staging_rxon is compared to active_rxon
+ *
+ * If the RXON structure is changing enough to require a new tune,
+ * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
+ * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
+ */
+int iwl_full_rxon_required(struct iwl_priv *priv)
+{
+
+        /* These items are only settable from the full RXON command */
+        if (!(iwl_is_associated(priv)) ||
+            compare_ether_addr(priv->staging_rxon.bssid_addr,
+                               priv->active_rxon.bssid_addr) ||
+            compare_ether_addr(priv->staging_rxon.node_addr,
+                               priv->active_rxon.node_addr) ||
+            compare_ether_addr(priv->staging_rxon.wlap_bssid_addr,
+                               priv->active_rxon.wlap_bssid_addr) ||
+            (priv->staging_rxon.dev_type != priv->active_rxon.dev_type) ||
+            (priv->staging_rxon.channel != priv->active_rxon.channel) ||
+            (priv->staging_rxon.air_propagation !=
+             priv->active_rxon.air_propagation) ||
+            (priv->staging_rxon.ofdm_ht_single_stream_basic_rates !=
+             priv->active_rxon.ofdm_ht_single_stream_basic_rates) ||
+            (priv->staging_rxon.ofdm_ht_dual_stream_basic_rates !=
+             priv->active_rxon.ofdm_ht_dual_stream_basic_rates) ||
+            (priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
+                return 1;
+
+        /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
+         * be updated with the RXON_ASSOC command -- however only some
+         * flag transitions are allowed using RXON_ASSOC */
+
+        /* Check if we are not switching bands */
+        if ((priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
+            (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK))
+                return 1;
+
+        /* Check if we are switching association toggle */
+        if ((priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
+                (priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
+                return 1;
+
+        return 0;
+}
+EXPORT_SYMBOL(iwl_full_rxon_required);
+
+u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv)
+{
+        int i;
+        int rate_mask;
+
+        /* Set rate mask*/
+        if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
+                rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
+        else
+                rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
+
+        /* Find lowest valid rate */
+        for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
+                                        i = iwl_rates[i].next_ieee) {
+                if (rate_mask & (1 << i))
+                        return iwl_rates[i].plcp;
+        }
+
+        /* No valid rate was found. Assign the lowest one */
+        if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
+                return IWL_RATE_1M_PLCP;
+        else
+                return IWL_RATE_6M_PLCP;
+}
+EXPORT_SYMBOL(iwl_rate_get_lowest_plcp);
+
 void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_info *ht_info)
 {
         struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
@@ -821,6 +984,277 @@ int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch)
 }
 EXPORT_SYMBOL(iwl_set_rxon_channel);
 
+void iwl_set_flags_for_band(struct iwl_priv *priv,
+                            enum ieee80211_band band)
+{
+        if (band == IEEE80211_BAND_5GHZ) {
+                priv->staging_rxon.flags &=
+                    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
+                      | RXON_FLG_CCK_MSK);
+                priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
+        } else {
+                /* Copied from iwl_post_associate() */
+                if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
+                        priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
+                else
+                        priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
+
+                if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
+                        priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
+
+                priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
+                priv->staging_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
+                priv->staging_rxon.flags &= ~RXON_FLG_CCK_MSK;
+        }
+}
+EXPORT_SYMBOL(iwl_set_flags_for_band);
+
+/*
+ * initialize rxon structure with default values from eeprom
+ */
+void iwl_connection_init_rx_config(struct iwl_priv *priv, int mode)
+{
+        const struct iwl_channel_info *ch_info;
+
+        memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
+
+        switch (mode) {
+        case NL80211_IFTYPE_AP:
+                priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
+                break;
+
+        case NL80211_IFTYPE_STATION:
+                priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
+                priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
+                break;
+
+        case NL80211_IFTYPE_ADHOC:
+                priv->staging_rxon.dev_type = RXON_DEV_TYPE_IBSS;
+                priv->staging_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
+                priv->staging_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
+                                                  RXON_FILTER_ACCEPT_GRP_MSK;
+                break;
+
+        case NL80211_IFTYPE_MONITOR:
+                priv->staging_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
+                priv->staging_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
+                    RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
+                break;
+        default:
+                IWL_ERR(priv, "Unsupported interface type %d\n", mode);
+                break;
+        }
+
+#if 0
+        /* TODO:  Figure out when short_preamble would be set and cache from
+         * that */
+        if (!hw_to_local(priv->hw)->short_preamble)
+                priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+        else
+                priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+#endif
+
+        ch_info = iwl_get_channel_info(priv, priv->band,
+                                       le16_to_cpu(priv->active_rxon.channel));
+
+        if (!ch_info)
+                ch_info = &priv->channel_info[0];
+
+        /*
+         * in some case A channels are all non IBSS
+         * in this case force B/G channel
+         */
+        if ((priv->iw_mode == NL80211_IFTYPE_ADHOC) &&
+            !(is_channel_ibss(ch_info)))
+                ch_info = &priv->channel_info[0];
+
+        priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
+        priv->band = ch_info->band;
+
+        iwl_set_flags_for_band(priv, priv->band);
+
+        priv->staging_rxon.ofdm_basic_rates =
+            (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
+        priv->staging_rxon.cck_basic_rates =
+            (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
+
+        priv->staging_rxon.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED_MSK |
+                                        RXON_FLG_CHANNEL_MODE_PURE_40_MSK);
+        memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
+        memcpy(priv->staging_rxon.wlap_bssid_addr, priv->mac_addr, ETH_ALEN);
+        priv->staging_rxon.ofdm_ht_single_stream_basic_rates = 0xff;
+        priv->staging_rxon.ofdm_ht_dual_stream_basic_rates = 0xff;
+}
+EXPORT_SYMBOL(iwl_connection_init_rx_config);
+
+void iwl_set_rate(struct iwl_priv *priv)
+{
+        const struct ieee80211_supported_band *hw = NULL;
+        struct ieee80211_rate *rate;
+        int i;
+
+        hw = iwl_get_hw_mode(priv, priv->band);
+        if (!hw) {
+                IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
+                return;
+        }
+
+        priv->active_rate = 0;
+        priv->active_rate_basic = 0;
+
+        for (i = 0; i < hw->n_bitrates; i++) {
+                rate = &(hw->bitrates[i]);
+                if (rate->hw_value < IWL_RATE_COUNT)
+                        priv->active_rate |= (1 << rate->hw_value);
+        }
+
+        IWL_DEBUG_RATE("Set active_rate = %0x, active_rate_basic = %0x\n",
+                       priv->active_rate, priv->active_rate_basic);
+
+        /*
+         * If a basic rate is configured, then use it (adding IWL_RATE_1M_MASK)
+         * otherwise set it to the default of all CCK rates and 6, 12, 24 for
+         * OFDM
+         */
+        if (priv->active_rate_basic & IWL_CCK_BASIC_RATES_MASK)
+                priv->staging_rxon.cck_basic_rates =
+                    ((priv->active_rate_basic &
+                      IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
+        else
+                priv->staging_rxon.cck_basic_rates =
+                    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
+
+        if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
+                priv->staging_rxon.ofdm_basic_rates =
+                    ((priv->active_rate_basic &
+                      (IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
+                      IWL_FIRST_OFDM_RATE) & 0xFF;
+        else
+                priv->staging_rxon.ofdm_basic_rates =
+                   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
+}
+EXPORT_SYMBOL(iwl_set_rate);
+
+void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
+{
+        struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
+        struct iwl_rxon_cmd *rxon = (void *)&priv->active_rxon;
+        struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
+        IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
+                      le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
+        rxon->channel = csa->channel;
+        priv->staging_rxon.channel = csa->channel;
+}
+EXPORT_SYMBOL(iwl_rx_csa);
+
+#ifdef CONFIG_IWLWIFI_DEBUG
+static void iwl_print_rx_config_cmd(struct iwl_priv *priv)
+{
+        struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
+
+        IWL_DEBUG_RADIO("RX CONFIG:\n");
+        iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
+        IWL_DEBUG_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
+        IWL_DEBUG_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
+        IWL_DEBUG_RADIO("u32 filter_flags: 0x%08x\n",
+                        le32_to_cpu(rxon->filter_flags));
+        IWL_DEBUG_RADIO("u8 dev_type: 0x%x\n", rxon->dev_type);
+        IWL_DEBUG_RADIO("u8 ofdm_basic_rates: 0x%02x\n",
+                        rxon->ofdm_basic_rates);
+        IWL_DEBUG_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
+        IWL_DEBUG_RADIO("u8[6] node_addr: %pM\n", rxon->node_addr);
+        IWL_DEBUG_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
+        IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
+}
+#endif
+
+/**
+ * iwl_irq_handle_error - called for HW or SW error interrupt from card
+ */
+void iwl_irq_handle_error(struct iwl_priv *priv)
+{
+        /* Set the FW error flag -- cleared on iwl_down */
+        set_bit(STATUS_FW_ERROR, &priv->status);
+
+        /* Cancel currently queued command. */
+        clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
+
+#ifdef CONFIG_IWLWIFI_DEBUG
+        if (priv->debug_level & IWL_DL_FW_ERRORS) {
+                iwl_dump_nic_error_log(priv);
+                iwl_dump_nic_event_log(priv);
+                iwl_print_rx_config_cmd(priv);
+        }
+#endif
+
+        wake_up_interruptible(&priv->wait_command_queue);
+
+        /* Keep the restart process from trying to send host
+         * commands by clearing the INIT status bit */
+        clear_bit(STATUS_READY, &priv->status);
+
+        if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
+                IWL_DEBUG(IWL_DL_FW_ERRORS,
+                          "Restarting adapter due to uCode error.\n");
+
+                if (iwl_is_associated(priv)) {
+                        memcpy(&priv->recovery_rxon, &priv->active_rxon,
+                               sizeof(priv->recovery_rxon));
+                        priv->error_recovering = 1;
+                }
+                if (priv->cfg->mod_params->restart_fw)
+                        queue_work(priv->workqueue, &priv->restart);
+        }
+}
+EXPORT_SYMBOL(iwl_irq_handle_error);
+
+void iwl_configure_filter(struct ieee80211_hw *hw,
+                          unsigned int changed_flags,
+                          unsigned int *total_flags,
+                          int mc_count, struct dev_addr_list *mc_list)
+{
+        struct iwl_priv *priv = hw->priv;
+        __le32 *filter_flags = &priv->staging_rxon.filter_flags;
+
+        IWL_DEBUG_MAC80211("Enter: changed: 0x%x, total: 0x%x\n",
+                        changed_flags, *total_flags);
+
+        if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
+                if (*total_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))
+                        *filter_flags |= RXON_FILTER_PROMISC_MSK;
+                else
+                        *filter_flags &= ~RXON_FILTER_PROMISC_MSK;
+        }
+        if (changed_flags & FIF_ALLMULTI) {
+                if (*total_flags & FIF_ALLMULTI)
+                        *filter_flags |= RXON_FILTER_ACCEPT_GRP_MSK;
+                else
+                        *filter_flags &= ~RXON_FILTER_ACCEPT_GRP_MSK;
+        }
+        if (changed_flags & FIF_CONTROL) {
+                if (*total_flags & FIF_CONTROL)
+                        *filter_flags |= RXON_FILTER_CTL2HOST_MSK;
+                else
+                        *filter_flags &= ~RXON_FILTER_CTL2HOST_MSK;
+        }
+        if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
+                if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
+                        *filter_flags |= RXON_FILTER_BCON_AWARE_MSK;
+                else
+                        *filter_flags &= ~RXON_FILTER_BCON_AWARE_MSK;
+        }
+
+        /* We avoid iwl_commit_rxon here to commit the new filter flags
+         * since mac80211 will call ieee80211_hw_config immediately.
+         * (mc_list is not supported at this time). Otherwise, we need to
+         * queue a background iwl_commit_rxon work.
+         */
+
+        *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
+                        FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
+}
+EXPORT_SYMBOL(iwl_configure_filter);
+
 int iwl_setup_mac(struct iwl_priv *priv)
 {
         int ret;