|
|
@@ -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;
|
Samuel Ortiz