Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / drivers / net / wireless / iwlwifi / iwl-agn-rxon.c
1 /******************************************************************************
2  *
3  * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of version 2 of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17  *
18  * The full GNU General Public License is included in this distribution in the
19  * file called LICENSE.
20  *
21  * Contact Information:
22  * Intel Linux Wireless <ilw@linux.intel.com>
23  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24  *
25  *****************************************************************************/
26
27 #include "iwl-dev.h"
28 #include "iwl-agn.h"
29 #include "iwl-sta.h"
30 #include "iwl-core.h"
31 #include "iwl-agn-calib.h"
32 #include "iwl-helpers.h"
33
34 static int iwlagn_disable_bss(struct iwl_priv *priv,
35                               struct iwl_rxon_context *ctx,
36                               struct iwl_rxon_cmd *send)
37 {
38         __le32 old_filter = send->filter_flags;
39         int ret;
40
41         send->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
42         ret = iwl_send_cmd_pdu(priv, ctx->rxon_cmd, sizeof(*send), send);
43
44         send->filter_flags = old_filter;
45
46         if (ret)
47                 IWL_ERR(priv, "Error clearing ASSOC_MSK on BSS (%d)\n", ret);
48
49         return ret;
50 }
51
52 static int iwlagn_disable_pan(struct iwl_priv *priv,
53                               struct iwl_rxon_context *ctx,
54                               struct iwl_rxon_cmd *send)
55 {
56         struct iwl_notification_wait disable_wait;
57         __le32 old_filter = send->filter_flags;
58         u8 old_dev_type = send->dev_type;
59         int ret;
60
61         iwlagn_init_notification_wait(priv, &disable_wait,
62                                       REPLY_WIPAN_DEACTIVATION_COMPLETE,
63                                       NULL, NULL);
64
65         send->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
66         send->dev_type = RXON_DEV_TYPE_P2P;
67         ret = iwl_send_cmd_pdu(priv, ctx->rxon_cmd, sizeof(*send), send);
68
69         send->filter_flags = old_filter;
70         send->dev_type = old_dev_type;
71
72         if (ret) {
73                 IWL_ERR(priv, "Error disabling PAN (%d)\n", ret);
74                 iwlagn_remove_notification(priv, &disable_wait);
75         } else {
76                 ret = iwlagn_wait_notification(priv, &disable_wait, HZ);
77                 if (ret)
78                         IWL_ERR(priv, "Timed out waiting for PAN disable\n");
79         }
80
81         return ret;
82 }
83
84 static int iwlagn_disconn_pan(struct iwl_priv *priv,
85                               struct iwl_rxon_context *ctx,
86                               struct iwl_rxon_cmd *send)
87 {
88         __le32 old_filter = send->filter_flags;
89         int ret;
90
91         send->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
92         ret = iwl_send_cmd_pdu(priv, ctx->rxon_cmd, sizeof(*send), send);
93
94         send->filter_flags = old_filter;
95
96         return ret;
97 }
98
99 static void iwlagn_update_qos(struct iwl_priv *priv,
100                               struct iwl_rxon_context *ctx)
101 {
102         int ret;
103
104         if (!ctx->is_active)
105                 return;
106
107         ctx->qos_data.def_qos_parm.qos_flags = 0;
108
109         if (ctx->qos_data.qos_active)
110                 ctx->qos_data.def_qos_parm.qos_flags |=
111                         QOS_PARAM_FLG_UPDATE_EDCA_MSK;
112
113         if (ctx->ht.enabled)
114                 ctx->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;
115
116         IWL_DEBUG_QOS(priv, "send QoS cmd with Qos active=%d FLAGS=0x%X\n",
117                       ctx->qos_data.qos_active,
118                       ctx->qos_data.def_qos_parm.qos_flags);
119
120         ret = iwl_send_cmd_pdu(priv, ctx->qos_cmd,
121                                sizeof(struct iwl_qosparam_cmd),
122                                &ctx->qos_data.def_qos_parm);
123         if (ret)
124                 IWL_ERR(priv, "Failed to update QoS\n");
125 }
126
127 static int iwlagn_update_beacon(struct iwl_priv *priv,
128                                 struct ieee80211_vif *vif)
129 {
130         lockdep_assert_held(&priv->mutex);
131
132         dev_kfree_skb(priv->beacon_skb);
133         priv->beacon_skb = ieee80211_beacon_get(priv->hw, vif);
134         if (!priv->beacon_skb)
135                 return -ENOMEM;
136         return iwlagn_send_beacon_cmd(priv);
137 }
138
139 static int iwlagn_send_rxon_assoc(struct iwl_priv *priv,
140                            struct iwl_rxon_context *ctx)
141 {
142         int ret = 0;
143         struct iwl_rxon_assoc_cmd rxon_assoc;
144         const struct iwl_rxon_cmd *rxon1 = &ctx->staging;
145         const struct iwl_rxon_cmd *rxon2 = &ctx->active;
146
147         if ((rxon1->flags == rxon2->flags) &&
148             (rxon1->filter_flags == rxon2->filter_flags) &&
149             (rxon1->cck_basic_rates == rxon2->cck_basic_rates) &&
150             (rxon1->ofdm_ht_single_stream_basic_rates ==
151              rxon2->ofdm_ht_single_stream_basic_rates) &&
152             (rxon1->ofdm_ht_dual_stream_basic_rates ==
153              rxon2->ofdm_ht_dual_stream_basic_rates) &&
154             (rxon1->ofdm_ht_triple_stream_basic_rates ==
155              rxon2->ofdm_ht_triple_stream_basic_rates) &&
156             (rxon1->acquisition_data == rxon2->acquisition_data) &&
157             (rxon1->rx_chain == rxon2->rx_chain) &&
158             (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
159                 IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC.  Not resending.\n");
160                 return 0;
161         }
162
163         rxon_assoc.flags = ctx->staging.flags;
164         rxon_assoc.filter_flags = ctx->staging.filter_flags;
165         rxon_assoc.ofdm_basic_rates = ctx->staging.ofdm_basic_rates;
166         rxon_assoc.cck_basic_rates = ctx->staging.cck_basic_rates;
167         rxon_assoc.reserved1 = 0;
168         rxon_assoc.reserved2 = 0;
169         rxon_assoc.reserved3 = 0;
170         rxon_assoc.ofdm_ht_single_stream_basic_rates =
171             ctx->staging.ofdm_ht_single_stream_basic_rates;
172         rxon_assoc.ofdm_ht_dual_stream_basic_rates =
173             ctx->staging.ofdm_ht_dual_stream_basic_rates;
174         rxon_assoc.rx_chain_select_flags = ctx->staging.rx_chain;
175         rxon_assoc.ofdm_ht_triple_stream_basic_rates =
176                  ctx->staging.ofdm_ht_triple_stream_basic_rates;
177         rxon_assoc.acquisition_data = ctx->staging.acquisition_data;
178
179         ret = iwl_send_cmd_pdu_async(priv, ctx->rxon_assoc_cmd,
180                                      sizeof(rxon_assoc), &rxon_assoc, NULL);
181         if (ret)
182                 return ret;
183
184         return ret;
185 }
186
187 static int iwlagn_rxon_disconn(struct iwl_priv *priv,
188                                struct iwl_rxon_context *ctx)
189 {
190         int ret;
191         struct iwl_rxon_cmd *active = (void *)&ctx->active;
192
193         if (ctx->ctxid == IWL_RXON_CTX_BSS) {
194                 ret = iwlagn_disable_bss(priv, ctx, &ctx->staging);
195         } else {
196                 ret = iwlagn_disable_pan(priv, ctx, &ctx->staging);
197                 if (ret)
198                         return ret;
199                 if (ctx->vif) {
200                         ret = iwl_send_rxon_timing(priv, ctx);
201                         if (ret) {
202                                 IWL_ERR(priv, "Failed to send timing (%d)!\n", ret);
203                                 return ret;
204                         }
205                         ret = iwlagn_disconn_pan(priv, ctx, &ctx->staging);
206                 }
207         }
208         if (ret)
209                 return ret;
210
211         /*
212          * Un-assoc RXON clears the station table and WEP
213          * keys, so we have to restore those afterwards.
214          */
215         iwl_clear_ucode_stations(priv, ctx);
216         iwl_restore_stations(priv, ctx);
217         ret = iwl_restore_default_wep_keys(priv, ctx);
218         if (ret) {
219                 IWL_ERR(priv, "Failed to restore WEP keys (%d)\n", ret);
220                 return ret;
221         }
222
223         memcpy(active, &ctx->staging, sizeof(*active));
224         return 0;
225 }
226
227 static int iwlagn_rxon_connect(struct iwl_priv *priv,
228                                struct iwl_rxon_context *ctx)
229 {
230         int ret;
231         struct iwl_rxon_cmd *active = (void *)&ctx->active;
232
233         /* RXON timing must be before associated RXON */
234         if (ctx->ctxid == IWL_RXON_CTX_BSS) {
235                 ret = iwl_send_rxon_timing(priv, ctx);
236                 if (ret) {
237                         IWL_ERR(priv, "Failed to send timing (%d)!\n", ret);
238                         return ret;
239                 }
240         }
241         /* QoS info may be cleared by previous un-assoc RXON */
242         iwlagn_update_qos(priv, ctx);
243
244         /*
245          * We'll run into this code path when beaconing is
246          * enabled, but then we also need to send the beacon
247          * to the device.
248          */
249         if (ctx->vif && (ctx->vif->type == NL80211_IFTYPE_AP)) {
250                 ret = iwlagn_update_beacon(priv, ctx->vif);
251                 if (ret) {
252                         IWL_ERR(priv,
253                                 "Error sending required beacon (%d)!\n",
254                                 ret);
255                         return ret;
256                 }
257         }
258
259         priv->start_calib = 0;
260         /*
261          * Apply the new configuration.
262          *
263          * Associated RXON doesn't clear the station table in uCode,
264          * so we don't need to restore stations etc. after this.
265          */
266         ret = iwl_send_cmd_pdu(priv, ctx->rxon_cmd,
267                       sizeof(struct iwl_rxon_cmd), &ctx->staging);
268         if (ret) {
269                 IWL_ERR(priv, "Error setting new RXON (%d)\n", ret);
270                 return ret;
271         }
272         memcpy(active, &ctx->staging, sizeof(*active));
273
274         iwl_reprogram_ap_sta(priv, ctx);
275
276         /* IBSS beacon needs to be sent after setting assoc */
277         if (ctx->vif && (ctx->vif->type == NL80211_IFTYPE_ADHOC))
278                 if (iwlagn_update_beacon(priv, ctx->vif))
279                         IWL_ERR(priv, "Error sending IBSS beacon\n");
280         iwl_init_sensitivity(priv);
281
282         /*
283          * If we issue a new RXON command which required a tune then
284          * we must send a new TXPOWER command or we won't be able to
285          * Tx any frames.
286          *
287          * It's expected we set power here if channel is changing.
288          */
289         ret = iwl_set_tx_power(priv, priv->tx_power_next, true);
290         if (ret) {
291                 IWL_ERR(priv, "Error sending TX power (%d)\n", ret);
292                 return ret;
293         }
294
295         if ((ctx->vif && ctx->vif->type == NL80211_IFTYPE_STATION) &&
296             priv->cfg->ht_params->smps_mode)
297                 ieee80211_request_smps(ctx->vif,
298                                        priv->cfg->ht_params->smps_mode);
299
300         return 0;
301 }
302
303 /**
304  * iwlagn_commit_rxon - commit staging_rxon to hardware
305  *
306  * The RXON command in staging_rxon is committed to the hardware and
307  * the active_rxon structure is updated with the new data.  This
308  * function correctly transitions out of the RXON_ASSOC_MSK state if
309  * a HW tune is required based on the RXON structure changes.
310  *
311  * The connect/disconnect flow should be as the following:
312  *
313  * 1. make sure send RXON command with association bit unset if not connect
314  *      this should include the channel and the band for the candidate
315  *      to be connected to
316  * 2. Add Station before RXON association with the AP
317  * 3. RXON_timing has to send before RXON for connection
318  * 4. full RXON command - associated bit set
319  * 5. use RXON_ASSOC command to update any flags changes
320  */
321 int iwlagn_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
322 {
323         /* cast away the const for active_rxon in this function */
324         struct iwl_rxon_cmd *active = (void *)&ctx->active;
325         bool new_assoc = !!(ctx->staging.filter_flags & RXON_FILTER_ASSOC_MSK);
326         int ret;
327
328         lockdep_assert_held(&priv->mutex);
329
330         if (test_bit(STATUS_EXIT_PENDING, &priv->status))
331                 return -EINVAL;
332
333         if (!iwl_is_alive(priv))
334                 return -EBUSY;
335
336         /* This function hardcodes a bunch of dual-mode assumptions */
337         BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
338
339         if (!ctx->is_active)
340                 return 0;
341
342         /* always get timestamp with Rx frame */
343         ctx->staging.flags |= RXON_FLG_TSF2HOST_MSK;
344
345         if (ctx->ctxid == IWL_RXON_CTX_PAN && priv->_agn.hw_roc_channel) {
346                 struct ieee80211_channel *chan = priv->_agn.hw_roc_channel;
347
348                 iwl_set_rxon_channel(priv, chan, ctx);
349                 iwl_set_flags_for_band(priv, ctx, chan->band, NULL);
350                 ctx->staging.filter_flags |=
351                         RXON_FILTER_ASSOC_MSK |
352                         RXON_FILTER_PROMISC_MSK |
353                         RXON_FILTER_CTL2HOST_MSK;
354                 ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
355                 new_assoc = true;
356
357                 if (memcmp(&ctx->staging, &ctx->active,
358                            sizeof(ctx->staging)) == 0)
359                         return 0;
360         }
361
362         /*
363          * force CTS-to-self frames protection if RTS-CTS is not preferred
364          * one aggregation protection method
365          */
366         if (!(priv->cfg->ht_params &&
367               priv->cfg->ht_params->use_rts_for_aggregation))
368                 ctx->staging.flags |= RXON_FLG_SELF_CTS_EN;
369
370         if ((ctx->vif && ctx->vif->bss_conf.use_short_slot) ||
371             !(ctx->staging.flags & RXON_FLG_BAND_24G_MSK))
372                 ctx->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
373         else
374                 ctx->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
375
376         iwl_print_rx_config_cmd(priv, ctx);
377         ret = iwl_check_rxon_cmd(priv, ctx);
378         if (ret) {
379                 IWL_ERR(priv, "Invalid RXON configuration. Not committing.\n");
380                 return -EINVAL;
381         }
382
383         /*
384          * receive commit_rxon request
385          * abort any previous channel switch if still in process
386          */
387         if (test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status) &&
388             (priv->switch_channel != ctx->staging.channel)) {
389                 IWL_DEBUG_11H(priv, "abort channel switch on %d\n",
390                               le16_to_cpu(priv->switch_channel));
391                 iwl_chswitch_done(priv, false);
392         }
393
394         /*
395          * If we don't need to send a full RXON, we can use
396          * iwl_rxon_assoc_cmd which is used to reconfigure filter
397          * and other flags for the current radio configuration.
398          */
399         if (!iwl_full_rxon_required(priv, ctx)) {
400                 ret = iwlagn_send_rxon_assoc(priv, ctx);
401                 if (ret) {
402                         IWL_ERR(priv, "Error setting RXON_ASSOC (%d)\n", ret);
403                         return ret;
404                 }
405
406                 memcpy(active, &ctx->staging, sizeof(*active));
407                 /*
408                  * We do not commit tx power settings while channel changing,
409                  * do it now if after settings changed.
410                  */
411                 iwl_set_tx_power(priv, priv->tx_power_next, false);
412
413                 /* make sure we are in the right PS state */
414                 iwl_power_update_mode(priv, true);
415
416                 return 0;
417         }
418
419         iwl_set_rxon_hwcrypto(priv, ctx, !iwlagn_mod_params.sw_crypto);
420
421         IWL_DEBUG_INFO(priv,
422                        "Going to commit RXON\n"
423                        "  * with%s RXON_FILTER_ASSOC_MSK\n"
424                        "  * channel = %d\n"
425                        "  * bssid = %pM\n",
426                        (new_assoc ? "" : "out"),
427                        le16_to_cpu(ctx->staging.channel),
428                        ctx->staging.bssid_addr);
429
430         /*
431          * Always clear associated first, but with the correct config.
432          * This is required as for example station addition for the
433          * AP station must be done after the BSSID is set to correctly
434          * set up filters in the device.
435          */
436         ret = iwlagn_rxon_disconn(priv, ctx);
437         if (ret)
438                 return ret;
439
440         if (priv->cfg->ops->hcmd->set_pan_params) {
441                 ret = priv->cfg->ops->hcmd->set_pan_params(priv);
442                 if (ret)
443                         return ret;
444         }
445
446         if (new_assoc)
447                 return iwlagn_rxon_connect(priv, ctx);
448
449         return 0;
450 }
451
452 int iwlagn_mac_config(struct ieee80211_hw *hw, u32 changed)
453 {
454         struct iwl_priv *priv = hw->priv;
455         struct iwl_rxon_context *ctx;
456         struct ieee80211_conf *conf = &hw->conf;
457         struct ieee80211_channel *channel = conf->channel;
458         const struct iwl_channel_info *ch_info;
459         int ret = 0;
460
461         IWL_DEBUG_MAC80211(priv, "changed %#x", changed);
462
463         mutex_lock(&priv->mutex);
464
465         if (unlikely(test_bit(STATUS_SCANNING, &priv->status))) {
466                 IWL_DEBUG_MAC80211(priv, "leave - scanning\n");
467                 goto out;
468         }
469
470         if (!iwl_is_ready(priv)) {
471                 IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
472                 goto out;
473         }
474
475         if (changed & (IEEE80211_CONF_CHANGE_SMPS |
476                        IEEE80211_CONF_CHANGE_CHANNEL)) {
477                 /* mac80211 uses static for non-HT which is what we want */
478                 priv->current_ht_config.smps = conf->smps_mode;
479
480                 /*
481                  * Recalculate chain counts.
482                  *
483                  * If monitor mode is enabled then mac80211 will
484                  * set up the SM PS mode to OFF if an HT channel is
485                  * configured.
486                  */
487                 if (priv->cfg->ops->hcmd->set_rxon_chain)
488                         for_each_context(priv, ctx)
489                                 priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
490         }
491
492         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
493                 unsigned long flags;
494
495                 ch_info = iwl_get_channel_info(priv, channel->band,
496                                                channel->hw_value);
497                 if (!is_channel_valid(ch_info)) {
498                         IWL_DEBUG_MAC80211(priv, "leave - invalid channel\n");
499                         ret = -EINVAL;
500                         goto out;
501                 }
502
503                 spin_lock_irqsave(&priv->lock, flags);
504
505                 for_each_context(priv, ctx) {
506                         /* Configure HT40 channels */
507                         if (ctx->ht.enabled != conf_is_ht(conf))
508                                 ctx->ht.enabled = conf_is_ht(conf);
509
510                         if (ctx->ht.enabled) {
511                                 if (conf_is_ht40_minus(conf)) {
512                                         ctx->ht.extension_chan_offset =
513                                                 IEEE80211_HT_PARAM_CHA_SEC_BELOW;
514                                         ctx->ht.is_40mhz = true;
515                                 } else if (conf_is_ht40_plus(conf)) {
516                                         ctx->ht.extension_chan_offset =
517                                                 IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
518                                         ctx->ht.is_40mhz = true;
519                                 } else {
520                                         ctx->ht.extension_chan_offset =
521                                                 IEEE80211_HT_PARAM_CHA_SEC_NONE;
522                                         ctx->ht.is_40mhz = false;
523                                 }
524                         } else
525                                 ctx->ht.is_40mhz = false;
526
527                         /*
528                          * Default to no protection. Protection mode will
529                          * later be set from BSS config in iwl_ht_conf
530                          */
531                         ctx->ht.protection = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
532
533                         /* if we are switching from ht to 2.4 clear flags
534                          * from any ht related info since 2.4 does not
535                          * support ht */
536                         if (le16_to_cpu(ctx->staging.channel) !=
537                             channel->hw_value)
538                                 ctx->staging.flags = 0;
539
540                         iwl_set_rxon_channel(priv, channel, ctx);
541                         iwl_set_rxon_ht(priv, &priv->current_ht_config);
542
543                         iwl_set_flags_for_band(priv, ctx, channel->band,
544                                                ctx->vif);
545                 }
546
547                 spin_unlock_irqrestore(&priv->lock, flags);
548
549                 iwl_update_bcast_stations(priv);
550
551                 /*
552                  * The list of supported rates and rate mask can be different
553                  * for each band; since the band may have changed, reset
554                  * the rate mask to what mac80211 lists.
555                  */
556                 iwl_set_rate(priv);
557         }
558
559         if (changed & (IEEE80211_CONF_CHANGE_PS |
560                         IEEE80211_CONF_CHANGE_IDLE)) {
561                 ret = iwl_power_update_mode(priv, false);
562                 if (ret)
563                         IWL_DEBUG_MAC80211(priv, "Error setting sleep level\n");
564         }
565
566         if (changed & IEEE80211_CONF_CHANGE_POWER) {
567                 IWL_DEBUG_MAC80211(priv, "TX Power old=%d new=%d\n",
568                         priv->tx_power_user_lmt, conf->power_level);
569
570                 iwl_set_tx_power(priv, conf->power_level, false);
571         }
572
573         for_each_context(priv, ctx) {
574                 if (!memcmp(&ctx->staging, &ctx->active, sizeof(ctx->staging)))
575                         continue;
576                 iwlagn_commit_rxon(priv, ctx);
577         }
578  out:
579         mutex_unlock(&priv->mutex);
580         return ret;
581 }
582
583 static void iwlagn_check_needed_chains(struct iwl_priv *priv,
584                                        struct iwl_rxon_context *ctx,
585                                        struct ieee80211_bss_conf *bss_conf)
586 {
587         struct ieee80211_vif *vif = ctx->vif;
588         struct iwl_rxon_context *tmp;
589         struct ieee80211_sta *sta;
590         struct iwl_ht_config *ht_conf = &priv->current_ht_config;
591         struct ieee80211_sta_ht_cap *ht_cap;
592         bool need_multiple;
593
594         lockdep_assert_held(&priv->mutex);
595
596         switch (vif->type) {
597         case NL80211_IFTYPE_STATION:
598                 rcu_read_lock();
599                 sta = ieee80211_find_sta(vif, bss_conf->bssid);
600                 if (!sta) {
601                         /*
602                          * If at all, this can only happen through a race
603                          * when the AP disconnects us while we're still
604                          * setting up the connection, in that case mac80211
605                          * will soon tell us about that.
606                          */
607                         need_multiple = false;
608                         rcu_read_unlock();
609                         break;
610                 }
611
612                 ht_cap = &sta->ht_cap;
613
614                 need_multiple = true;
615
616                 /*
617                  * If the peer advertises no support for receiving 2 and 3
618                  * stream MCS rates, it can't be transmitting them either.
619                  */
620                 if (ht_cap->mcs.rx_mask[1] == 0 &&
621                     ht_cap->mcs.rx_mask[2] == 0) {
622                         need_multiple = false;
623                 } else if (!(ht_cap->mcs.tx_params &
624                                                 IEEE80211_HT_MCS_TX_DEFINED)) {
625                         /* If it can't TX MCS at all ... */
626                         need_multiple = false;
627                 } else if (ht_cap->mcs.tx_params &
628                                                 IEEE80211_HT_MCS_TX_RX_DIFF) {
629                         int maxstreams;
630
631                         /*
632                          * But if it can receive them, it might still not
633                          * be able to transmit them, which is what we need
634                          * to check here -- so check the number of streams
635                          * it advertises for TX (if different from RX).
636                          */
637
638                         maxstreams = (ht_cap->mcs.tx_params &
639                                  IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK);
640                         maxstreams >>=
641                                 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
642                         maxstreams += 1;
643
644                         if (maxstreams <= 1)
645                                 need_multiple = false;
646                 }
647
648                 rcu_read_unlock();
649                 break;
650         case NL80211_IFTYPE_ADHOC:
651                 /* currently */
652                 need_multiple = false;
653                 break;
654         default:
655                 /* only AP really */
656                 need_multiple = true;
657                 break;
658         }
659
660         ctx->ht_need_multiple_chains = need_multiple;
661
662         if (!need_multiple) {
663                 /* check all contexts */
664                 for_each_context(priv, tmp) {
665                         if (!tmp->vif)
666                                 continue;
667                         if (tmp->ht_need_multiple_chains) {
668                                 need_multiple = true;
669                                 break;
670                         }
671                 }
672         }
673
674         ht_conf->single_chain_sufficient = !need_multiple;
675 }
676
677 void iwlagn_bss_info_changed(struct ieee80211_hw *hw,
678                              struct ieee80211_vif *vif,
679                              struct ieee80211_bss_conf *bss_conf,
680                              u32 changes)
681 {
682         struct iwl_priv *priv = hw->priv;
683         struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
684         int ret;
685         bool force = false;
686
687         mutex_lock(&priv->mutex);
688
689         if (unlikely(!iwl_is_ready(priv))) {
690                 IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
691                 mutex_unlock(&priv->mutex);
692                 return;
693         }
694
695         if (unlikely(!ctx->vif)) {
696                 IWL_DEBUG_MAC80211(priv, "leave - vif is NULL\n");
697                 mutex_unlock(&priv->mutex);
698                 return;
699         }
700
701         if (changes & BSS_CHANGED_BEACON_INT)
702                 force = true;
703
704         if (changes & BSS_CHANGED_QOS) {
705                 ctx->qos_data.qos_active = bss_conf->qos;
706                 iwlagn_update_qos(priv, ctx);
707         }
708
709         ctx->staging.assoc_id = cpu_to_le16(vif->bss_conf.aid);
710         if (vif->bss_conf.use_short_preamble)
711                 ctx->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
712         else
713                 ctx->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
714
715         if (changes & BSS_CHANGED_ASSOC) {
716                 if (bss_conf->assoc) {
717                         priv->timestamp = bss_conf->timestamp;
718                         ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
719                 } else {
720                         /*
721                          * If we disassociate while there are pending
722                          * frames, just wake up the queues and let the
723                          * frames "escape" ... This shouldn't really
724                          * be happening to start with, but we should
725                          * not get stuck in this case either since it
726                          * can happen if userspace gets confused.
727                          */
728                         if (ctx->last_tx_rejected) {
729                                 ctx->last_tx_rejected = false;
730                                 iwl_wake_any_queue(priv, ctx);
731                         }
732                         ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
733                 }
734         }
735
736         if (ctx->ht.enabled) {
737                 ctx->ht.protection = bss_conf->ht_operation_mode &
738                                         IEEE80211_HT_OP_MODE_PROTECTION;
739                 ctx->ht.non_gf_sta_present = !!(bss_conf->ht_operation_mode &
740                                         IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
741                 iwlagn_check_needed_chains(priv, ctx, bss_conf);
742                 iwl_set_rxon_ht(priv, &priv->current_ht_config);
743         }
744
745         if (priv->cfg->ops->hcmd->set_rxon_chain)
746                 priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
747
748         if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
749                 ctx->staging.flags |= RXON_FLG_TGG_PROTECT_MSK;
750         else
751                 ctx->staging.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
752
753         if (bss_conf->use_cts_prot)
754                 ctx->staging.flags |= RXON_FLG_SELF_CTS_EN;
755         else
756                 ctx->staging.flags &= ~RXON_FLG_SELF_CTS_EN;
757
758         memcpy(ctx->staging.bssid_addr, bss_conf->bssid, ETH_ALEN);
759
760         if (vif->type == NL80211_IFTYPE_AP ||
761             vif->type == NL80211_IFTYPE_ADHOC) {
762                 if (vif->bss_conf.enable_beacon) {
763                         ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
764                         priv->beacon_ctx = ctx;
765                 } else {
766                         ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
767                         priv->beacon_ctx = NULL;
768                 }
769         }
770
771         if (force || memcmp(&ctx->staging, &ctx->active, sizeof(ctx->staging)))
772                 iwlagn_commit_rxon(priv, ctx);
773
774         if (changes & BSS_CHANGED_ASSOC && bss_conf->assoc) {
775                 /*
776                  * The chain noise calibration will enable PM upon
777                  * completion. If calibration has already been run
778                  * then we need to enable power management here.
779                  */
780                 if (priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE)
781                         iwl_power_update_mode(priv, false);
782
783                 /* Enable RX differential gain and sensitivity calibrations */
784                 iwl_chain_noise_reset(priv);
785                 priv->start_calib = 1;
786         }
787
788         if (changes & BSS_CHANGED_IBSS) {
789                 ret = iwlagn_manage_ibss_station(priv, vif,
790                                                  bss_conf->ibss_joined);
791                 if (ret)
792                         IWL_ERR(priv, "failed to %s IBSS station %pM\n",
793                                 bss_conf->ibss_joined ? "add" : "remove",
794                                 bss_conf->bssid);
795         }
796
797         if (changes & BSS_CHANGED_BEACON && vif->type == NL80211_IFTYPE_ADHOC &&
798             priv->beacon_ctx) {
799                 if (iwlagn_update_beacon(priv, vif))
800                         IWL_ERR(priv, "Error sending IBSS beacon\n");
801         }
802
803         mutex_unlock(&priv->mutex);
804 }
805
806 void iwlagn_post_scan(struct iwl_priv *priv)
807 {
808         struct iwl_rxon_context *ctx;
809
810         /*
811          * We do not commit power settings while scan is pending,
812          * do it now if the settings changed.
813          */
814         iwl_power_set_mode(priv, &priv->power_data.sleep_cmd_next, false);
815         iwl_set_tx_power(priv, priv->tx_power_next, false);
816
817         /*
818          * Since setting the RXON may have been deferred while
819          * performing the scan, fire one off if needed
820          */
821         for_each_context(priv, ctx)
822                 if (memcmp(&ctx->staging, &ctx->active, sizeof(ctx->staging)))
823                         iwlagn_commit_rxon(priv, ctx);
824
825         if (priv->cfg->ops->hcmd->set_pan_params)
826                 priv->cfg->ops->hcmd->set_pan_params(priv);
827 }