1 files changed, 143 insertions, 96 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index b775d5bab668..62b26befddc5 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -1160,7 +1160,7 @@ static int iwl3945_commit_rxon(struct iwl3945_priv *priv)
         /* If we have set the ASSOC_MSK and we are in BSS mode then
          * add the IWL_AP_ID to the station rate table */
         if (iwl3945_is_associated(priv) &&
-            (priv->iw_mode == IEEE80211_IF_TYPE_STA))
+            (priv->iw_mode == NL80211_IFTYPE_STATION))
                 if (iwl3945_add_station(priv, priv->active_rxon.bssid_addr, 1, 0)
                     == IWL_INVALID_STATION) {
                         IWL_ERROR("Error adding AP address for transmit.\n");
@@ -1447,8 +1447,8 @@ unsigned int iwl3945_fill_beacon_frame(struct iwl3945_priv *priv,
 {
 
         if (!iwl3945_is_associated(priv) || !priv->ibss_beacon ||
-            ((priv->iw_mode != IEEE80211_IF_TYPE_IBSS) &&
-             (priv->iw_mode != IEEE80211_IF_TYPE_AP)))
+            ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
+             (priv->iw_mode != NL80211_IFTYPE_AP)))
                 return 0;
 
         if (priv->ibss_beacon->len > left)
@@ -1746,14 +1746,14 @@ static void iwl3945_reset_qos(struct iwl3945_priv *priv)
         spin_lock_irqsave(&priv->lock, flags);
         priv->qos_data.qos_active = 0;
 
-        if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS) {
+        if (priv->iw_mode == NL80211_IFTYPE_ADHOC) {
                 if (priv->qos_data.qos_enable)
                         priv->qos_data.qos_active = 1;
                 if (!(priv->active_rate & 0xfff0)) {
                         cw_min = 31;
                         is_legacy = 1;
                 }
-        } else if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
+        } else if (priv->iw_mode == NL80211_IFTYPE_AP) {
                 if (priv->qos_data.qos_enable)
                         priv->qos_data.qos_active = 1;
         } else if (!(priv->staging_rxon.flags & RXON_FLG_SHORT_SLOT_MSK)) {
@@ -2120,7 +2120,7 @@ static void iwl3945_setup_rxon_timing(struct iwl3945_priv *priv)
         beacon_int = priv->beacon_int;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        if (priv->iw_mode == IEEE80211_IF_TYPE_STA) {
+        if (priv->iw_mode == NL80211_IFTYPE_STATION) {
                 if (beacon_int == 0) {
                         priv->rxon_timing.beacon_interval = cpu_to_le16(100);
                         priv->rxon_timing.beacon_init_val = cpu_to_le32(102400);
@@ -2156,7 +2156,7 @@ static void iwl3945_setup_rxon_timing(struct iwl3945_priv *priv)
 
 static int iwl3945_scan_initiate(struct iwl3945_priv *priv)
 {
-        if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
+        if (priv->iw_mode == NL80211_IFTYPE_AP) {
                 IWL_ERROR("APs don't scan.\n");
                 return 0;
         }
@@ -2218,7 +2218,7 @@ static void iwl3945_set_flags_for_phymode(struct iwl3945_priv *priv,
                 else
                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 
-                if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS)
+                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;
@@ -2237,23 +2237,23 @@ static void iwl3945_connection_init_rx_config(struct iwl3945_priv *priv)
         memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
 
         switch (priv->iw_mode) {
-        case IEEE80211_IF_TYPE_AP:
+        case NL80211_IFTYPE_AP:
                 priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
                 break;
 
-        case IEEE80211_IF_TYPE_STA:
+        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 IEEE80211_IF_TYPE_IBSS:
+        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 IEEE80211_IF_TYPE_MNTR:
+        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;
@@ -2282,7 +2282,7 @@ static void iwl3945_connection_init_rx_config(struct iwl3945_priv *priv)
          * in some case A channels are all non IBSS
          * in this case force B/G channel
          */
-        if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
+        if ((priv->iw_mode == NL80211_IFTYPE_ADHOC) &&
             !(is_channel_ibss(ch_info)))
                 ch_info = &priv->channel_info[0];
 
@@ -2302,7 +2302,7 @@ static void iwl3945_connection_init_rx_config(struct iwl3945_priv *priv)
 
 static int iwl3945_set_mode(struct iwl3945_priv *priv, int mode)
 {
-        if (mode == IEEE80211_IF_TYPE_IBSS) {
+        if (mode == NL80211_IFTYPE_ADHOC) {
                 const struct iwl3945_channel_info *ch_info;
 
                 ch_info = iwl3945_get_channel_info(priv,
@@ -2469,11 +2469,11 @@ static int iwl3945_get_sta_id(struct iwl3945_priv *priv, struct ieee80211_hdr *h
 
         /* If we are a client station in a BSS network, use the special
          * AP station entry (that's the only station we communicate with) */
-        case IEEE80211_IF_TYPE_STA:
+        case NL80211_IFTYPE_STATION:
                 return IWL_AP_ID;
 
         /* If we are an AP, then find the station, or use BCAST */
-        case IEEE80211_IF_TYPE_AP:
+        case NL80211_IFTYPE_AP:
                 sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
                 if (sta_id != IWL_INVALID_STATION)
                         return sta_id;
@@ -2481,7 +2481,7 @@ static int iwl3945_get_sta_id(struct iwl3945_priv *priv, struct ieee80211_hdr *h
 
         /* If this frame is going out to an IBSS network, find the station,
          * or create a new station table entry */
-        case IEEE80211_IF_TYPE_IBSS: {
+        case NL80211_IFTYPE_ADHOC: {
                 DECLARE_MAC_BUF(mac);
 
                 /* Create new station table entry */
@@ -2502,7 +2502,7 @@ static int iwl3945_get_sta_id(struct iwl3945_priv *priv, struct ieee80211_hdr *h
         }
         /* If we are in monitor mode, use BCAST. This is required for
          * packet injection. */
-        case IEEE80211_IF_TYPE_MNTR:
+        case NL80211_IFTYPE_MONITOR:
                 return priv->hw_setting.bcast_sta_id;
 
         default:
@@ -2565,16 +2565,16 @@ static int iwl3945_tx_skb(struct iwl3945_priv *priv, struct sk_buff *skb)
 
         /* drop all data frame if we are not associated */
         if (ieee80211_is_data(fc) &&
-            (priv->iw_mode != IEEE80211_IF_TYPE_MNTR) && /* packet injection */
+            (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
             (!iwl3945_is_associated(priv) ||
-             ((priv->iw_mode == IEEE80211_IF_TYPE_STA) && !priv->assoc_id))) {
+             ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
                 IWL_DEBUG_DROP("Dropping - !iwl3945_is_associated\n");
                 goto drop_unlock;
         }
 
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        hdr_len = ieee80211_get_hdrlen(le16_to_cpu(fc));
+        hdr_len = ieee80211_hdrlen(fc);
 
         /* Find (or create) index into station table for destination station */
         sta_id = iwl3945_get_sta_id(priv, hdr);
@@ -2590,7 +2590,7 @@ static int iwl3945_tx_skb(struct iwl3945_priv *priv, struct sk_buff *skb)
 
         if (ieee80211_is_data_qos(fc)) {
                 qc = ieee80211_get_qos_ctl(hdr);
-                tid = qc[0] & 0xf;
+                tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
                 seq_number = priv->stations[sta_id].tid[tid].seq_number &
                                 IEEE80211_SCTL_SEQ;
                 hdr->seq_ctrl = cpu_to_le16(seq_number) |
@@ -2709,7 +2709,7 @@ static int iwl3945_tx_skb(struct iwl3945_priv *priv, struct sk_buff *skb)
                            sizeof(out_cmd->cmd.tx));
 
         iwl3945_print_hex_dump(IWL_DL_TX, (u8 *)out_cmd->cmd.tx.hdr,
-                           ieee80211_get_hdrlen(le16_to_cpu(fc)));
+                           ieee80211_hdrlen(fc));
 
         /* Tell device the write index *just past* this latest filled TFD */
         q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
@@ -2806,7 +2806,7 @@ static void iwl3945_radio_kill_sw(struct iwl3945_priv *priv, int disable_radio)
         if (disable_radio) {
                 iwl3945_scan_cancel(priv);
                 /* FIXME: This is a workaround for AP */
-                if (priv->iw_mode != IEEE80211_IF_TYPE_AP) {
+                if (priv->iw_mode != NL80211_IFTYPE_AP) {
                         spin_lock_irqsave(&priv->lock, flags);
                         iwl3945_write32(priv, CSR_UCODE_DRV_GP1_SET,
                                     CSR_UCODE_SW_BIT_RFKILL);
@@ -3161,7 +3161,7 @@ static void iwl3945_rx_beacon_notif(struct iwl3945_priv *priv,
                 le32_to_cpu(beacon->low_tsf), rate);
 #endif
 
-        if ((priv->iw_mode == IEEE80211_IF_TYPE_AP) &&
+        if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
             (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
                 queue_work(priv->workqueue, &priv->beacon_update);
 }
@@ -4782,8 +4782,11 @@ static void iwl3945_free_channel_map(struct iwl3945_priv *priv)
 /* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
  * sending probe req.  This should be set long enough to hear probe responses
  * from more than one AP.  */
-#define IWL_ACTIVE_DWELL_TIME_24    (20)        /* all times in msec */
-#define IWL_ACTIVE_DWELL_TIME_52    (10)
+#define IWL_ACTIVE_DWELL_TIME_24    (30)        /* all times in msec */
+#define IWL_ACTIVE_DWELL_TIME_52    (20)
+
+#define IWL_ACTIVE_DWELL_FACTOR_24GHZ (3)
+#define IWL_ACTIVE_DWELL_FACTOR_52GHZ (2)
 
 /* For faster active scanning, scan will move to the next channel if fewer than
  * PLCP_QUIET_THRESH packets are heard on this channel within
@@ -4792,7 +4795,7 @@ static void iwl3945_free_channel_map(struct iwl3945_priv *priv)
  * no other traffic).
  * Disable "quiet" feature by setting PLCP_QUIET_THRESH to 0. */
 #define IWL_PLCP_QUIET_THRESH       __constant_cpu_to_le16(1)   /* packets */
-#define IWL_ACTIVE_QUIET_TIME       __constant_cpu_to_le16(5)   /* msec */
+#define IWL_ACTIVE_QUIET_TIME       __constant_cpu_to_le16(10)  /* msec */
 
 /* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
  * Must be set longer than active dwell time.
@@ -4802,19 +4805,23 @@ static void iwl3945_free_channel_map(struct iwl3945_priv *priv)
 #define IWL_PASSIVE_DWELL_BASE      (100)
 #define IWL_CHANNEL_TUNE_TIME       5
 
+#define IWL_SCAN_PROBE_MASK(n)   cpu_to_le32((BIT(n) | (BIT(n) - BIT(1))))
+
 static inline u16 iwl3945_get_active_dwell_time(struct iwl3945_priv *priv,
-                                                enum ieee80211_band band)
+                                                enum ieee80211_band band,
+                                                u8 n_probes)
 {
         if (band == IEEE80211_BAND_5GHZ)
-                return IWL_ACTIVE_DWELL_TIME_52;
+                return IWL_ACTIVE_DWELL_TIME_52 +
+                        IWL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
         else
-                return IWL_ACTIVE_DWELL_TIME_24;
+                return IWL_ACTIVE_DWELL_TIME_24 +
+                        IWL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
 }
 
 static u16 iwl3945_get_passive_dwell_time(struct iwl3945_priv *priv,
                                           enum ieee80211_band band)
 {
-        u16 active = iwl3945_get_active_dwell_time(priv, band);
         u16 passive = (band == IEEE80211_BAND_2GHZ) ?
             IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
             IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;
@@ -4829,15 +4836,12 @@ static u16 iwl3945_get_passive_dwell_time(struct iwl3945_priv *priv,
                 passive = (passive * 98) / 100 - IWL_CHANNEL_TUNE_TIME * 2;
         }
 
-        if (passive <= active)
-                passive = active + 1;
-
         return passive;
 }
 
 static int iwl3945_get_channels_for_scan(struct iwl3945_priv *priv,
                                          enum ieee80211_band band,
-                                     u8 is_active, u8 direct_mask,
+                                     u8 is_active, u8 n_probes,
                                      struct iwl3945_scan_channel *scan_ch)
 {
         const struct ieee80211_channel *channels = NULL;
@@ -4853,9 +4857,12 @@ static int iwl3945_get_channels_for_scan(struct iwl3945_priv *priv,
 
         channels = sband->channels;
 
-        active_dwell = iwl3945_get_active_dwell_time(priv, band);
+        active_dwell = iwl3945_get_active_dwell_time(priv, band, n_probes);
         passive_dwell = iwl3945_get_passive_dwell_time(priv, band);
 
+        if (passive_dwell <= active_dwell)
+                passive_dwell = active_dwell + 1;
+
         for (i = 0, added = 0; i < sband->n_channels; i++) {
                 if (channels[i].flags & IEEE80211_CHAN_DISABLED)
                         continue;
@@ -4875,8 +4882,8 @@ static int iwl3945_get_channels_for_scan(struct iwl3945_priv *priv,
                 else
                         scan_ch->type = 1;      /* active */
 
-                if (scan_ch->type & 1)
-                        scan_ch->type |= (direct_mask << 1);
+                if ((scan_ch->type & 1) && n_probes)
+                        scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes);
 
                 scan_ch->active_dwell = cpu_to_le16(active_dwell);
                 scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
@@ -6052,7 +6059,7 @@ static void iwl3945_bg_set_monitor(struct work_struct *work)
         if (!iwl3945_is_ready(priv))
                 IWL_DEBUG(IWL_DL_STATE, "leave - not ready\n");
         else
-                if (iwl3945_set_mode(priv, IEEE80211_IF_TYPE_MNTR) != 0)
+                if (iwl3945_set_mode(priv, NL80211_IFTYPE_MONITOR) != 0)
                         IWL_ERROR("iwl3945_set_mode() failed\n");
 
         mutex_unlock(&priv->mutex);
@@ -6093,7 +6100,7 @@ static void iwl3945_bg_request_scan(struct work_struct *data)
         int rc = 0;
         struct iwl3945_scan_cmd *scan;
         struct ieee80211_conf *conf = NULL;
-        u8 direct_mask;
+        u8 n_probes = 2;
         enum ieee80211_band band;
 
         conf = ieee80211_get_hw_conf(priv->hw);
@@ -6201,7 +6208,7 @@ static void iwl3945_bg_request_scan(struct work_struct *data)
                 scan->direct_scan[0].len = priv->direct_ssid_len;
                 memcpy(scan->direct_scan[0].ssid,
                        priv->direct_ssid, priv->direct_ssid_len);
-                direct_mask = 1;
+                n_probes++;
         } else if (!iwl3945_is_associated(priv) && priv->essid_len) {
                 IWL_DEBUG_SCAN
                   ("Kicking off one direct scan for '%s' when not associated\n",
@@ -6209,11 +6216,9 @@ static void iwl3945_bg_request_scan(struct work_struct *data)
                 scan->direct_scan[0].id = WLAN_EID_SSID;
                 scan->direct_scan[0].len = priv->essid_len;
                 memcpy(scan->direct_scan[0].ssid, priv->essid, priv->essid_len);
-                direct_mask = 1;
-        } else {
+                n_probes++;
+        } else
                 IWL_DEBUG_SCAN("Kicking off one indirect scan.\n");
-                direct_mask = 0;
-        }
 
         /* We don't build a direct scan probe request; the uCode will do
          * that based on the direct_mask added to each channel entry */
@@ -6243,21 +6248,13 @@ static void iwl3945_bg_request_scan(struct work_struct *data)
         /* select Rx antennas */
         scan->flags |= iwl3945_get_antenna_flags(priv);
 
-        if (priv->iw_mode == IEEE80211_IF_TYPE_MNTR)
+        if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
                 scan->filter_flags = RXON_FILTER_PROMISC_MSK;
 
-        if (direct_mask)
-                scan->channel_count =
-                        iwl3945_get_channels_for_scan(
-                                priv, band, 1, /* active */
-                                direct_mask,
-                                (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
-        else
-                scan->channel_count =
-                        iwl3945_get_channels_for_scan(
-                                priv, band, 0, /* passive */
-                                direct_mask,
-                                (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
+        scan->channel_count =
+                iwl3945_get_channels_for_scan(priv, band, 1, /* active */
+                                              n_probes,
+                        (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
 
         cmd.len += le16_to_cpu(scan->tx_cmd.len) +
             scan->channel_count * sizeof(struct iwl3945_scan_channel);
@@ -6320,16 +6317,13 @@ static void iwl3945_bg_rx_replenish(struct work_struct *data)
 
 #define IWL_DELAY_NEXT_SCAN (HZ*2)
 
-static void iwl3945_bg_post_associate(struct work_struct *data)
+static void iwl3945_post_associate(struct iwl3945_priv *priv)
 {
-        struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv,
-                                             post_associate.work);
-
         int rc = 0;
         struct ieee80211_conf *conf = NULL;
         DECLARE_MAC_BUF(mac);
 
-        if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
+        if (priv->iw_mode == NL80211_IFTYPE_AP) {
                 IWL_ERROR("%s Should not be called in AP mode\n", __func__);
                 return;
         }
@@ -6342,12 +6336,9 @@ static void iwl3945_bg_post_associate(struct work_struct *data)
         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
                 return;
 
-        mutex_lock(&priv->mutex);
-
-        if (!priv->vif || !priv->is_open) {
-                mutex_unlock(&priv->mutex);
+        if (!priv->vif || !priv->is_open)
                 return;
-        }
+
         iwl3945_scan_cancel_timeout(priv, 200);
 
         conf = ieee80211_get_hw_conf(priv->hw);
@@ -6381,7 +6372,7 @@ static void iwl3945_bg_post_associate(struct work_struct *data)
                 else
                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 
-                if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS)
+                if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
                         priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
 
         }
@@ -6389,11 +6380,11 @@ static void iwl3945_bg_post_associate(struct work_struct *data)
         iwl3945_commit_rxon(priv);
 
         switch (priv->iw_mode) {
-        case IEEE80211_IF_TYPE_STA:
+        case NL80211_IFTYPE_STATION:
                 iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
                 break;
 
-        case IEEE80211_IF_TYPE_IBSS:
+        case NL80211_IFTYPE_ADHOC:
 
                 /* clear out the station table */
                 iwl3945_clear_stations_table(priv);
@@ -6419,7 +6410,6 @@ static void iwl3945_bg_post_associate(struct work_struct *data)
 
         /* we have just associated, don't start scan too early */
         priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
-        mutex_unlock(&priv->mutex);
 }
 
 static void iwl3945_bg_abort_scan(struct work_struct *work)
@@ -6567,7 +6557,6 @@ static void iwl3945_mac_stop(struct ieee80211_hw *hw)
                  */
                 mutex_lock(&priv->mutex);
                 iwl3945_scan_cancel_timeout(priv, 100);
-                cancel_delayed_work(&priv->post_associate);
                 mutex_unlock(&priv->mutex);
         }
 
@@ -6650,8 +6639,6 @@ static int iwl3945_mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *co
         mutex_lock(&priv->mutex);
         IWL_DEBUG_MAC80211("enter to channel %d\n", conf->channel->hw_value);
 
-        priv->add_radiotap = !!(conf->flags & IEEE80211_CONF_RADIOTAP);
-
         if (!iwl3945_is_ready(priv)) {
                 IWL_DEBUG_MAC80211("leave - not ready\n");
                 ret = -EIO;
@@ -6767,7 +6754,7 @@ static void iwl3945_config_ap(struct iwl3945_priv *priv)
                                 priv->staging_rxon.flags &=
                                         ~RXON_FLG_SHORT_SLOT_MSK;
 
-                        if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS)
+                        if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
                                 priv->staging_rxon.flags &=
                                         ~RXON_FLG_SHORT_SLOT_MSK;
                 }
@@ -6804,7 +6791,7 @@ static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
         }
 
         /* handle this temporarily here */
-        if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS &&
+        if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
             conf->changed & IEEE80211_IFCC_BEACON) {
                 struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
                 if (!beacon)
@@ -6816,7 +6803,7 @@ static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
 
         /* XXX: this MUST use conf->mac_addr */
 
-        if ((priv->iw_mode == IEEE80211_IF_TYPE_AP) &&
+        if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
             (!conf->ssid_len)) {
                 IWL_DEBUG_MAC80211
                     ("Leaving in AP mode because HostAPD is not ready.\n");
@@ -6839,7 +6826,7 @@ static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
             !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
  */
 
-        if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
+        if (priv->iw_mode == NL80211_IFTYPE_AP) {
                 if (!conf->bssid) {
                         conf->bssid = priv->mac_addr;
                         memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
@@ -6874,11 +6861,11 @@ static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
                  * to verify) - jpk */
                 memcpy(priv->bssid, conf->bssid, ETH_ALEN);
 
-                if (priv->iw_mode == IEEE80211_IF_TYPE_AP)
+                if (priv->iw_mode == NL80211_IFTYPE_AP)
                         iwl3945_config_ap(priv);
                 else {
                         rc = iwl3945_commit_rxon(priv);
-                        if ((priv->iw_mode == IEEE80211_IF_TYPE_STA) && rc)
+                        if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
                                 iwl3945_add_station(priv,
                                         priv->active_rxon.bssid_addr, 1, 0);
                 }
@@ -6914,7 +6901,7 @@ static void iwl3945_configure_filter(struct ieee80211_hw *hw,
 
         if (changed_flags & (*total_flags) & FIF_OTHER_BSS) {
                 IWL_DEBUG_MAC80211("Enter: type %d (0x%x, 0x%x)\n",
-                                   IEEE80211_IF_TYPE_MNTR,
+                                   NL80211_IFTYPE_MONITOR,
                                    changed_flags, *total_flags);
                 /* queue work 'cuz mac80211 is holding a lock which
                  * prevents us from issuing (synchronous) f/w cmds */
@@ -6935,7 +6922,6 @@ static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
 
         if (iwl3945_is_ready_rf(priv)) {
                 iwl3945_scan_cancel_timeout(priv, 100);
-                cancel_delayed_work(&priv->post_associate);
                 priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
                 iwl3945_commit_rxon(priv);
         }
@@ -6950,6 +6936,63 @@ static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
         IWL_DEBUG_MAC80211("leave\n");
 }
 
+#define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
+
+static void iwl3945_bss_info_changed(struct ieee80211_hw *hw,
+                                     struct ieee80211_vif *vif,
+                                     struct ieee80211_bss_conf *bss_conf,
+                                     u32 changes)
+{
+        struct iwl3945_priv *priv = hw->priv;
+
+        IWL_DEBUG_MAC80211("changes = 0x%X\n", changes);
+
+        if (changes & BSS_CHANGED_ERP_PREAMBLE) {
+                IWL_DEBUG_MAC80211("ERP_PREAMBLE %d\n",
+                                   bss_conf->use_short_preamble);
+                if (bss_conf->use_short_preamble)
+                        priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
+                else
+                        priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
+        }
+
+        if (changes & BSS_CHANGED_ERP_CTS_PROT) {
+                IWL_DEBUG_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
+                if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
+                        priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
+                else
+                        priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
+        }
+
+        if (changes & BSS_CHANGED_ASSOC) {
+                IWL_DEBUG_MAC80211("ASSOC %d\n", bss_conf->assoc);
+                /* This should never happen as this function should
+                 * never be called from interrupt context. */
+                if (WARN_ON_ONCE(in_interrupt()))
+                        return;
+                if (bss_conf->assoc) {
+                        priv->assoc_id = bss_conf->aid;
+                        priv->beacon_int = bss_conf->beacon_int;
+                        priv->timestamp0 = bss_conf->timestamp & 0xFFFFFFFF;
+                        priv->timestamp1 = (bss_conf->timestamp >> 32) &
+                                             0xFFFFFFFF;
+                        priv->assoc_capability = bss_conf->assoc_capability;
+                        priv->next_scan_jiffies = jiffies +
+                                        IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
+                        mutex_lock(&priv->mutex);
+                        iwl3945_post_associate(priv);
+                        mutex_unlock(&priv->mutex);
+                } else {
+                        priv->assoc_id = 0;
+                        IWL_DEBUG_MAC80211("DISASSOC %d\n", bss_conf->assoc);
+                }
+        } else if (changes && iwl3945_is_associated(priv) && priv->assoc_id) {
+                        IWL_DEBUG_MAC80211("Associated Changes %d\n", changes);
+                        iwl3945_send_rxon_assoc(priv);
+        }
+
+}
+
 static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
 {
         int rc = 0;
@@ -6967,7 +7010,7 @@ static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
                 goto out_unlock;
         }
 
-        if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {    /* APs don't scan */
+        if (priv->iw_mode == NL80211_IFTYPE_AP) {       /* APs don't scan */
                 rc = -EIO;
                 IWL_ERROR("ERROR: APs don't scan\n");
                 goto out_unlock;
@@ -7109,7 +7152,7 @@ static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
         spin_unlock_irqrestore(&priv->lock, flags);
 
         mutex_lock(&priv->mutex);
-        if (priv->iw_mode == IEEE80211_IF_TYPE_AP)
+        if (priv->iw_mode == NL80211_IFTYPE_AP)
                 iwl3945_activate_qos(priv, 1);
         else if (priv->assoc_id && iwl3945_is_associated(priv))
                 iwl3945_activate_qos(priv, 0);
@@ -7182,8 +7225,6 @@ static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
 
         iwl3945_reset_qos(priv);
 
-        cancel_delayed_work(&priv->post_associate);
-
         spin_lock_irqsave(&priv->lock, flags);
         priv->assoc_id = 0;
         priv->assoc_capability = 0;
@@ -7198,7 +7239,7 @@ static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
         priv->beacon_int = priv->hw->conf.beacon_int;
         priv->timestamp1 = 0;
         priv->timestamp0 = 0;
-        if ((priv->iw_mode == IEEE80211_IF_TYPE_STA))
+        if ((priv->iw_mode == NL80211_IFTYPE_STATION))
                 priv->beacon_int = 0;
 
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -7212,14 +7253,14 @@ static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
         /* we are restarting association process
          * clear RXON_FILTER_ASSOC_MSK bit
         */
-        if (priv->iw_mode != IEEE80211_IF_TYPE_AP) {
+        if (priv->iw_mode != NL80211_IFTYPE_AP) {
                 iwl3945_scan_cancel_timeout(priv, 100);
                 priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
                 iwl3945_commit_rxon(priv);
         }
 
         /* Per mac80211.h: This is only used in IBSS mode... */
-        if (priv->iw_mode != IEEE80211_IF_TYPE_IBSS) {
+        if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
 
                 IWL_DEBUG_MAC80211("leave - not in IBSS\n");
                 mutex_unlock(&priv->mutex);
@@ -7248,7 +7289,7 @@ static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *sk
                 return -EIO;
         }
 
-        if (priv->iw_mode != IEEE80211_IF_TYPE_IBSS) {
+        if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
                 IWL_DEBUG_MAC80211("leave - not IBSS\n");
                 mutex_unlock(&priv->mutex);
                 return -EIO;
@@ -7268,7 +7309,7 @@ static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *sk
 
         iwl3945_reset_qos(priv);
 
-        queue_work(priv->workqueue, &priv->post_associate.work);
+        iwl3945_post_associate(priv);
 
         mutex_unlock(&priv->mutex);
 
@@ -7767,7 +7808,6 @@ static void iwl3945_setup_deferred_work(struct iwl3945_priv *priv)
         INIT_WORK(&priv->rf_kill, iwl3945_bg_rf_kill);
         INIT_WORK(&priv->beacon_update, iwl3945_bg_beacon_update);
         INIT_WORK(&priv->set_monitor, iwl3945_bg_set_monitor);
-        INIT_DELAYED_WORK(&priv->post_associate, iwl3945_bg_post_associate);
         INIT_DELAYED_WORK(&priv->init_alive_start, iwl3945_bg_init_alive_start);
         INIT_DELAYED_WORK(&priv->alive_start, iwl3945_bg_alive_start);
         INIT_DELAYED_WORK(&priv->scan_check, iwl3945_bg_scan_check);
@@ -7785,7 +7825,6 @@ static void iwl3945_cancel_deferred_work(struct iwl3945_priv *priv)
         cancel_delayed_work_sync(&priv->init_alive_start);
         cancel_delayed_work(&priv->scan_check);
         cancel_delayed_work(&priv->alive_start);
-        cancel_delayed_work(&priv->post_associate);
         cancel_work_sync(&priv->beacon_update);
 }
 
@@ -7830,6 +7869,7 @@ static struct ieee80211_ops iwl3945_hw_ops = {
         .conf_tx = iwl3945_mac_conf_tx,
         .get_tsf = iwl3945_mac_get_tsf,
         .reset_tsf = iwl3945_mac_reset_tsf,
+        .bss_info_changed = iwl3945_bss_info_changed,
         .hw_scan = iwl3945_mac_hw_scan
 };
 
@@ -7890,6 +7930,11 @@ static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e
         hw->flags = IEEE80211_HW_SIGNAL_DBM |
                     IEEE80211_HW_NOISE_DBM;
 
+        hw->wiphy->interface_modes =
+                BIT(NL80211_IFTYPE_AP) |
+                BIT(NL80211_IFTYPE_STATION) |
+                BIT(NL80211_IFTYPE_ADHOC);
+
         /* 4 EDCA QOS priorities */
         hw->queues = 4;
 
@@ -7951,7 +7996,7 @@ static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *e
                 IWL_DEBUG_INFO("Radio disabled.\n");
         }
 
-        priv->iw_mode = IEEE80211_IF_TYPE_STA;
+        priv->iw_mode = NL80211_IFTYPE_STATION;
 
         printk(KERN_INFO DRV_NAME
                 ": Detected Intel Wireless WiFi Link %s\n", priv->cfg->name);
@@ -8331,6 +8376,8 @@ static void __exit iwl3945_exit(void)
         iwl3945_rate_control_unregister();
 }
 
+MODULE_FIRMWARE("iwlwifi-3945" IWL3945_UCODE_API ".ucode");
+
 module_param_named(antenna, iwl3945_param_antenna, int, 0444);
 MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
 module_param_named(disable, iwl3945_param_disable, int, 0444);