mac80211: update to 2011-11-15 from trunk
[openwrt-10.03/.git] / package / mac80211 / patches / 300-pending_work.patch
1 --- a/drivers/net/wireless/ath/ath9k/main.c
2 +++ b/drivers/net/wireless/ath/ath9k/main.c
3 @@ -118,7 +118,7 @@ void ath9k_ps_restore(struct ath_softc *
4         if (--sc->ps_usecount != 0)
5                 goto unlock;
6  
7 -       if (sc->ps_idle)
8 +       if (sc->ps_idle && (sc->ps_flags & PS_WAIT_FOR_TX_ACK))
9                 mode = ATH9K_PM_FULL_SLEEP;
10         else if (sc->ps_enabled &&
11                  !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
12 @@ -332,7 +332,8 @@ static int ath_reset_internal(struct ath
13                 hchan = ah->curchan;
14         }
15  
16 -       if (fastcc && !ath9k_hw_check_alive(ah))
17 +       if (fastcc && (ah->chip_fullsleep ||
18 +           !ath9k_hw_check_alive(ah)))
19                 fastcc = false;
20  
21         if (!ath_prepare_reset(sc, retry_tx, flush))
22 @@ -882,82 +883,6 @@ chip_reset:
23  #undef SCHED_INTR
24  }
25  
26 -static void ath_radio_enable(struct ath_softc *sc, struct ieee80211_hw *hw)
27 -{
28 -       struct ath_hw *ah = sc->sc_ah;
29 -       struct ath_common *common = ath9k_hw_common(ah);
30 -       struct ieee80211_channel *channel = hw->conf.channel;
31 -       int r;
32 -
33 -       ath9k_ps_wakeup(sc);
34 -       spin_lock_bh(&sc->sc_pcu_lock);
35 -       atomic_set(&ah->intr_ref_cnt, -1);
36 -
37 -       ath9k_hw_configpcipowersave(ah, false);
38 -
39 -       if (!ah->curchan)
40 -               ah->curchan = ath9k_cmn_get_curchannel(sc->hw, ah);
41 -
42 -       r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
43 -       if (r) {
44 -               ath_err(common,
45 -                       "Unable to reset channel (%u MHz), reset status %d\n",
46 -                       channel->center_freq, r);
47 -       }
48 -
49 -       ath_complete_reset(sc, true);
50 -
51 -       /* Enable LED */
52 -       ath9k_hw_cfg_output(ah, ah->led_pin,
53 -                           AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
54 -       ath9k_hw_set_gpio(ah, ah->led_pin, 0);
55 -
56 -       spin_unlock_bh(&sc->sc_pcu_lock);
57 -
58 -       ath9k_ps_restore(sc);
59 -}
60 -
61 -void ath_radio_disable(struct ath_softc *sc, struct ieee80211_hw *hw)
62 -{
63 -       struct ath_hw *ah = sc->sc_ah;
64 -       struct ieee80211_channel *channel = hw->conf.channel;
65 -       int r;
66 -
67 -       ath9k_ps_wakeup(sc);
68 -
69 -       ath_cancel_work(sc);
70 -
71 -       spin_lock_bh(&sc->sc_pcu_lock);
72 -
73 -       /*
74 -        * Keep the LED on when the radio is disabled
75 -        * during idle unassociated state.
76 -        */
77 -       if (!sc->ps_idle) {
78 -               ath9k_hw_set_gpio(ah, ah->led_pin, 1);
79 -               ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
80 -       }
81 -
82 -       ath_prepare_reset(sc, false, true);
83 -
84 -       if (!ah->curchan)
85 -               ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
86 -
87 -       r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
88 -       if (r) {
89 -               ath_err(ath9k_hw_common(sc->sc_ah),
90 -                       "Unable to reset channel (%u MHz), reset status %d\n",
91 -                       channel->center_freq, r);
92 -       }
93 -
94 -       ath9k_hw_phy_disable(ah);
95 -
96 -       ath9k_hw_configpcipowersave(ah, true);
97 -
98 -       spin_unlock_bh(&sc->sc_pcu_lock);
99 -       ath9k_ps_restore(sc);
100 -}
101 -
102  static int ath_reset(struct ath_softc *sc, bool retry_tx)
103  {
104         int r;
105 @@ -1093,6 +1018,9 @@ static int ath9k_start(struct ieee80211_
106          * and then setup of the interrupt mask.
107          */
108         spin_lock_bh(&sc->sc_pcu_lock);
109 +
110 +       atomic_set(&ah->intr_ref_cnt, -1);
111 +
112         r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
113         if (r) {
114                 ath_err(common,
115 @@ -1131,6 +1059,18 @@ static int ath9k_start(struct ieee80211_
116                 goto mutex_unlock;
117         }
118  
119 +       if (ah->led_pin >= 0) {
120 +               ath9k_hw_cfg_output(ah, ah->led_pin,
121 +                                   AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
122 +               ath9k_hw_set_gpio(ah, ah->led_pin, 0);
123 +       }
124 +
125 +       /*
126 +        * Reset key cache to sane defaults (all entries cleared) instead of
127 +        * semi-random values after suspend/resume.
128 +        */
129 +       ath9k_cmn_init_crypto(sc->sc_ah);
130 +
131         spin_unlock_bh(&sc->sc_pcu_lock);
132  
133         if ((ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE) &&
134 @@ -1176,6 +1116,13 @@ static void ath9k_tx(struct ieee80211_hw
135                 }
136         }
137  
138 +       /*
139 +        * Cannot tx while the hardware is in full sleep, it first needs a full
140 +        * chip reset to recover from that
141 +        */
142 +       if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_FULL_SLEEP))
143 +               goto exit;
144 +
145         if (unlikely(sc->sc_ah->power_mode != ATH9K_PM_AWAKE)) {
146                 /*
147                  * We are using PS-Poll and mac80211 can request TX while in
148 @@ -1222,6 +1169,7 @@ static void ath9k_stop(struct ieee80211_
149         struct ath_softc *sc = hw->priv;
150         struct ath_hw *ah = sc->sc_ah;
151         struct ath_common *common = ath9k_hw_common(ah);
152 +       bool prev_idle;
153  
154         mutex_lock(&sc->mutex);
155  
156 @@ -1252,35 +1200,45 @@ static void ath9k_stop(struct ieee80211_
157          * before setting the invalid flag. */
158         ath9k_hw_disable_interrupts(ah);
159  
160 -       if (!(sc->sc_flags & SC_OP_INVALID)) {
161 -               ath_drain_all_txq(sc, false);
162 -               ath_stoprecv(sc);
163 -               ath9k_hw_phy_disable(ah);
164 -       } else
165 -               sc->rx.rxlink = NULL;
166 +       spin_unlock_bh(&sc->sc_pcu_lock);
167 +
168 +       /* we can now sync irq and kill any running tasklets, since we already
169 +        * disabled interrupts and not holding a spin lock */
170 +       synchronize_irq(sc->irq);
171 +       tasklet_kill(&sc->intr_tq);
172 +       tasklet_kill(&sc->bcon_tasklet);
173 +
174 +       prev_idle = sc->ps_idle;
175 +       sc->ps_idle = true;
176 +
177 +       spin_lock_bh(&sc->sc_pcu_lock);
178 +
179 +       if (ah->led_pin >= 0) {
180 +               ath9k_hw_set_gpio(ah, ah->led_pin, 1);
181 +               ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
182 +       }
183 +
184 +       ath_prepare_reset(sc, false, true);
185  
186         if (sc->rx.frag) {
187                 dev_kfree_skb_any(sc->rx.frag);
188                 sc->rx.frag = NULL;
189         }
190  
191 -       /* disable HAL and put h/w to sleep */
192 -       ath9k_hw_disable(ah);
193 +       if (!ah->curchan)
194 +               ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
195  
196 -       spin_unlock_bh(&sc->sc_pcu_lock);
197 +       ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
198 +       ath9k_hw_phy_disable(ah);
199  
200 -       /* we can now sync irq and kill any running tasklets, since we already
201 -        * disabled interrupts and not holding a spin lock */
202 -       synchronize_irq(sc->irq);
203 -       tasklet_kill(&sc->intr_tq);
204 -       tasklet_kill(&sc->bcon_tasklet);
205 +       ath9k_hw_configpcipowersave(ah, true);
206  
207 -       ath9k_ps_restore(sc);
208 +       spin_unlock_bh(&sc->sc_pcu_lock);
209  
210 -       sc->ps_idle = true;
211 -       ath_radio_disable(sc, hw);
212 +       ath9k_ps_restore(sc);
213  
214         sc->sc_flags |= SC_OP_INVALID;
215 +       sc->ps_idle = prev_idle;
216  
217         mutex_unlock(&sc->mutex);
218  
219 @@ -1620,8 +1578,8 @@ static int ath9k_config(struct ieee80211
220         struct ath_hw *ah = sc->sc_ah;
221         struct ath_common *common = ath9k_hw_common(ah);
222         struct ieee80211_conf *conf = &hw->conf;
223 -       bool disable_radio = false;
224  
225 +       ath9k_ps_wakeup(sc);
226         mutex_lock(&sc->mutex);
227  
228         /*
229 @@ -1632,13 +1590,8 @@ static int ath9k_config(struct ieee80211
230          */
231         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
232                 sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
233 -               if (!sc->ps_idle) {
234 -                       ath_radio_enable(sc, hw);
235 -                       ath_dbg(common, ATH_DBG_CONFIG,
236 -                               "not-idle: enabling radio\n");
237 -               } else {
238 -                       disable_radio = true;
239 -               }
240 +               if (sc->ps_idle)
241 +                       ath_cancel_work(sc);
242         }
243  
244         /*
245 @@ -1745,18 +1698,12 @@ static int ath9k_config(struct ieee80211
246                 ath_dbg(common, ATH_DBG_CONFIG,
247                         "Set power: %d\n", conf->power_level);
248                 sc->config.txpowlimit = 2 * conf->power_level;
249 -               ath9k_ps_wakeup(sc);
250                 ath9k_cmn_update_txpow(ah, sc->curtxpow,
251                                        sc->config.txpowlimit, &sc->curtxpow);
252 -               ath9k_ps_restore(sc);
253 -       }
254 -
255 -       if (disable_radio) {
256 -               ath_dbg(common, ATH_DBG_CONFIG, "idle: disabling radio\n");
257 -               ath_radio_disable(sc, hw);
258         }
259  
260         mutex_unlock(&sc->mutex);
261 +       ath9k_ps_restore(sc);
262  
263         return 0;
264  }
265 @@ -2324,9 +2271,6 @@ static void ath9k_flush(struct ieee80211
266                 return;
267         }
268  
269 -       if (drop)
270 -               timeout = 1;
271 -
272         for (j = 0; j < timeout; j++) {
273                 bool npend = false;
274  
275 @@ -2344,21 +2288,22 @@ static void ath9k_flush(struct ieee80211
276                 }
277  
278                 if (!npend)
279 -                   goto out;
280 +                   break;
281         }
282  
283 -       ath9k_ps_wakeup(sc);
284 -       spin_lock_bh(&sc->sc_pcu_lock);
285 -       drain_txq = ath_drain_all_txq(sc, false);
286 -       spin_unlock_bh(&sc->sc_pcu_lock);
287 +       if (drop) {
288 +               ath9k_ps_wakeup(sc);
289 +               spin_lock_bh(&sc->sc_pcu_lock);
290 +               drain_txq = ath_drain_all_txq(sc, false);
291 +               spin_unlock_bh(&sc->sc_pcu_lock);
292  
293 -       if (!drain_txq)
294 -               ath_reset(sc, false);
295 +               if (!drain_txq)
296 +                       ath_reset(sc, false);
297  
298 -       ath9k_ps_restore(sc);
299 -       ieee80211_wake_queues(hw);
300 +               ath9k_ps_restore(sc);
301 +               ieee80211_wake_queues(hw);
302 +       }
303  
304 -out:
305         ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
306         mutex_unlock(&sc->mutex);
307  }
308 --- a/drivers/net/wireless/ath/ath9k/pci.c
309 +++ b/drivers/net/wireless/ath/ath9k/pci.c
310 @@ -307,12 +307,11 @@ static int ath_pci_suspend(struct device
311         struct ieee80211_hw *hw = pci_get_drvdata(pdev);
312         struct ath_softc *sc = hw->priv;
313  
314 -       ath9k_hw_set_gpio(sc->sc_ah, sc->sc_ah->led_pin, 1);
315 -
316         /* The device has to be moved to FULLSLEEP forcibly.
317          * Otherwise the chip never moved to full sleep,
318          * when no interface is up.
319          */
320 +       ath9k_hw_disable(sc->sc_ah);
321         ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_FULL_SLEEP);
322  
323         return 0;
324 @@ -334,22 +333,6 @@ static int ath_pci_resume(struct device 
325         if ((val & 0x0000ff00) != 0)
326                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
327  
328 -       ath9k_ps_wakeup(sc);
329 -       /* Enable LED */
330 -       ath9k_hw_cfg_output(sc->sc_ah, sc->sc_ah->led_pin,
331 -                           AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
332 -       ath9k_hw_set_gpio(sc->sc_ah, sc->sc_ah->led_pin, 0);
333 -
334 -         /*
335 -          * Reset key cache to sane defaults (all entries cleared) instead of
336 -          * semi-random values after suspend/resume.
337 -          */
338 -       ath9k_cmn_init_crypto(sc->sc_ah);
339 -       ath9k_ps_restore(sc);
340 -
341 -       sc->ps_idle = true;
342 -       ath_radio_disable(sc, hw);
343 -
344         return 0;
345  }
346  
347 --- a/drivers/net/wireless/ath/ath9k/xmit.c
348 +++ b/drivers/net/wireless/ath/ath9k/xmit.c
349 @@ -179,6 +179,11 @@ static void ath_tx_flush_tid(struct ath_
350                 spin_lock_bh(&txq->axq_lock);
351         }
352  
353 +       if (tid->baw_head == tid->baw_tail) {
354 +               tid->state &= ~AGGR_ADDBA_COMPLETE;
355 +               tid->state &= ~AGGR_CLEANUP;
356 +       }
357 +
358         spin_unlock_bh(&txq->axq_lock);
359  }
360  
361 @@ -556,15 +561,9 @@ static void ath_tx_complete_aggr(struct 
362                 spin_unlock_bh(&txq->axq_lock);
363         }
364  
365 -       if (tid->state & AGGR_CLEANUP) {
366 +       if (tid->state & AGGR_CLEANUP)
367                 ath_tx_flush_tid(sc, tid);
368  
369 -               if (tid->baw_head == tid->baw_tail) {
370 -                       tid->state &= ~AGGR_ADDBA_COMPLETE;
371 -                       tid->state &= ~AGGR_CLEANUP;
372 -               }
373 -       }
374 -
375         rcu_read_unlock();
376  
377         if (needreset) {
378 @@ -1955,7 +1954,7 @@ static void ath_tx_complete(struct ath_s
379                 skb_pull(skb, padsize);
380         }
381  
382 -       if (sc->ps_flags & PS_WAIT_FOR_TX_ACK) {
383 +       if ((sc->ps_flags & PS_WAIT_FOR_TX_ACK) && !txq->axq_depth) {
384                 sc->ps_flags &= ~PS_WAIT_FOR_TX_ACK;
385                 ath_dbg(common, ATH_DBG_PS,
386                         "Going back to sleep after having received TX status (0x%lx)\n",
387 --- a/include/net/cfg80211.h
388 +++ b/include/net/cfg80211.h
389 @@ -1130,6 +1130,7 @@ struct cfg80211_ibss_params {
390         u8 *ssid;
391         u8 *bssid;
392         struct ieee80211_channel *channel;
393 +       enum nl80211_channel_type channel_type;
394         u8 *ie;
395         u8 ssid_len, ie_len;
396         u16 beacon_interval;
397 @@ -3292,6 +3293,16 @@ void cfg80211_report_obss_beacon(struct 
398                                  const u8 *frame, size_t len,
399                                  int freq, gfp_t gfp);
400  
401 +/**
402 + * cfg80211_can_use_ext_chan - test if ht40 on extension channel can be used
403 + * @wiphy: the wiphy
404 + * @chan: main channel
405 + * @channel_type: HT mode
406 + */
407 +bool cfg80211_can_beacon_sec_chan(struct wiphy *wiphy,
408 +                                 struct ieee80211_channel *chan,
409 +                                 enum nl80211_channel_type channel_type);
410 +
411  /* Logging, debugging and troubleshooting/diagnostic helpers. */
412  
413  /* wiphy_printk helpers, similar to dev_printk */
414 --- a/net/mac80211/agg-rx.c
415 +++ b/net/mac80211/agg-rx.c
416 @@ -182,6 +182,10 @@ static void ieee80211_send_addba_resp(st
417                 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
418         else if (sdata->vif.type == NL80211_IFTYPE_STATION)
419                 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
420 +       else if (sdata->vif.type == NL80211_IFTYPE_WDS)
421 +               memcpy(mgmt->bssid, da, ETH_ALEN);
422 +       else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
423 +               memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
424  
425         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
426                                           IEEE80211_STYPE_ACTION);
427 --- a/net/mac80211/agg-tx.c
428 +++ b/net/mac80211/agg-tx.c
429 @@ -79,10 +79,13 @@ static void ieee80211_send_addba_request
430         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
431         if (sdata->vif.type == NL80211_IFTYPE_AP ||
432             sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
433 -           sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
434 +           sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
435 +           sdata->vif.type == NL80211_IFTYPE_WDS)
436                 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
437         else if (sdata->vif.type == NL80211_IFTYPE_STATION)
438                 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
439 +       else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
440 +               memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
441  
442         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
443                                           IEEE80211_STYPE_ACTION);
444 @@ -394,7 +397,9 @@ int ieee80211_start_tx_ba_session(struct
445         if (sdata->vif.type != NL80211_IFTYPE_STATION &&
446             sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
447             sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
448 -           sdata->vif.type != NL80211_IFTYPE_AP)
449 +           sdata->vif.type != NL80211_IFTYPE_AP &&
450 +           sdata->vif.type != NL80211_IFTYPE_ADHOC &&
451 +           sdata->vif.type != NL80211_IFTYPE_WDS)
452                 return -EINVAL;
453  
454         if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) {
455 --- a/net/mac80211/debugfs_sta.c
456 +++ b/net/mac80211/debugfs_sta.c
457 @@ -63,11 +63,11 @@ static ssize_t sta_flags_read(struct fil
458         test_sta_flag(sta, WLAN_STA_##flg) ? #flg "\n" : ""
459  
460         int res = scnprintf(buf, sizeof(buf),
461 -                           "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
462 +                           "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
463                             TEST(AUTH), TEST(ASSOC), TEST(PS_STA),
464                             TEST(PS_DRIVER), TEST(AUTHORIZED),
465                             TEST(SHORT_PREAMBLE), TEST(ASSOC_AP),
466 -                           TEST(WME), TEST(WDS), TEST(CLEAR_PS_FILT),
467 +                           TEST(WME), TEST(CLEAR_PS_FILT),
468                             TEST(MFP), TEST(BLOCK_BA), TEST(PSPOLL),
469                             TEST(UAPSD), TEST(SP), TEST(TDLS_PEER),
470                             TEST(TDLS_PEER_AUTH));
471 --- a/net/mac80211/ht.c
472 +++ b/net/mac80211/ht.c
473 @@ -201,6 +201,8 @@ void ieee80211_send_delba(struct ieee802
474                 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
475         else if (sdata->vif.type == NL80211_IFTYPE_STATION)
476                 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
477 +       else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
478 +               memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
479  
480         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
481                                           IEEE80211_STYPE_ACTION);
482 --- a/net/mac80211/ibss.c
483 +++ b/net/mac80211/ibss.c
484 @@ -77,6 +77,7 @@ static void __ieee80211_sta_join_ibss(st
485         struct cfg80211_bss *bss;
486         u32 bss_change;
487         u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
488 +       enum nl80211_channel_type channel_type;
489  
490         lockdep_assert_held(&ifibss->mtx);
491  
492 @@ -105,8 +106,16 @@ static void __ieee80211_sta_join_ibss(st
493  
494         sdata->drop_unencrypted = capability & WLAN_CAPABILITY_PRIVACY ? 1 : 0;
495  
496 -       local->oper_channel = chan;
497 -       WARN_ON(!ieee80211_set_channel_type(local, sdata, NL80211_CHAN_NO_HT));
498 +       channel_type = ifibss->channel_type;
499 +       if (channel_type > NL80211_CHAN_HT20 &&
500 +           !cfg80211_can_beacon_sec_chan(local->hw.wiphy, chan, channel_type))
501 +               channel_type = NL80211_CHAN_HT20;
502 +       if (!ieee80211_set_channel_type(local, sdata, channel_type)) {
503 +               /* can only fail due to HT40+/- mismatch */
504 +               channel_type = NL80211_CHAN_HT20;
505 +               WARN_ON(!ieee80211_set_channel_type(local, sdata,
506 +                                                   NL80211_CHAN_HT20));
507 +       }
508         ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
509  
510         sband = local->hw.wiphy->bands[chan->band];
511 @@ -172,6 +181,18 @@ static void __ieee80211_sta_join_ibss(st
512                 memcpy(skb_put(skb, ifibss->ie_len),
513                        ifibss->ie, ifibss->ie_len);
514  
515 +       /* add HT capability and information IEs */
516 +       if (channel_type && sband->ht_cap.ht_supported) {
517 +               pos = skb_put(skb, 4 +
518 +                                  sizeof(struct ieee80211_ht_cap) +
519 +                                  sizeof(struct ieee80211_ht_info));
520 +               pos = ieee80211_ie_build_ht_cap(pos, sband, sband->ht_cap.cap);
521 +               pos = ieee80211_ie_build_ht_info(pos,
522 +                                                &sband->ht_cap,
523 +                                                chan,
524 +                                                channel_type);
525 +       }
526 +
527         if (local->hw.queues >= 4) {
528                 pos = skb_put(skb, 9);
529                 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
530 @@ -195,6 +216,7 @@ static void __ieee80211_sta_join_ibss(st
531         bss_change |= BSS_CHANGED_BEACON;
532         bss_change |= BSS_CHANGED_BEACON_ENABLED;
533         bss_change |= BSS_CHANGED_BASIC_RATES;
534 +       bss_change |= BSS_CHANGED_HT;
535         bss_change |= BSS_CHANGED_IBSS;
536         sdata->vif.bss_conf.ibss_joined = true;
537         ieee80211_bss_info_change_notify(sdata, bss_change);
538 @@ -268,6 +290,7 @@ static void ieee80211_rx_bss_info(struct
539         u64 beacon_timestamp, rx_timestamp;
540         u32 supp_rates = 0;
541         enum ieee80211_band band = rx_status->band;
542 +       struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
543  
544         if (elems->ds_params && elems->ds_params_len == 1)
545                 freq = ieee80211_channel_to_frequency(elems->ds_params[0],
546 @@ -277,7 +300,10 @@ static void ieee80211_rx_bss_info(struct
547  
548         channel = ieee80211_get_channel(local->hw.wiphy, freq);
549  
550 -       if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
551 +       if (!channel ||
552 +           channel->flags & (IEEE80211_CHAN_DISABLED ||
553 +                             IEEE80211_CHAN_NO_IBSS ||
554 +                             IEEE80211_CHAN_RADAR))
555                 return;
556  
557         if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
558 @@ -315,8 +341,41 @@ static void ieee80211_rx_bss_info(struct
559                                                 GFP_ATOMIC);
560                 }
561  
562 -               if (sta && elems->wmm_info)
563 -                       set_sta_flag(sta, WLAN_STA_WME);
564 +               if (sta) {
565 +                       if (elems->wmm_info)
566 +                               set_sta_flag(sta, WLAN_STA_WME);
567 +
568 +                       /* we both use HT */
569 +                       if (elems->ht_info_elem && elems->ht_cap_elem &&
570 +                           sdata->u.ibss.channel_type) {
571 +                               enum nl80211_channel_type channel_type =
572 +                                       ieee80211_ht_info_to_channel_type(
573 +                                                          elems->ht_info_elem);
574 +                               struct ieee80211_sta_ht_cap sta_ht_cap_new;
575 +
576 +                               /*
577 +                                * fall back to HT20 if we don't use or use
578 +                                * the other extension channel
579 +                                */
580 +                               if (channel_type > NL80211_CHAN_HT20 &&
581 +                                   channel_type != sdata->u.ibss.channel_type)
582 +                                       channel_type = NL80211_CHAN_HT20;
583 +
584 +                               ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
585 +                                               elems->ht_cap_elem,
586 +                                               &sta_ht_cap_new);
587 +                               if (memcmp(&sta->sta.ht_cap, &sta_ht_cap_new,
588 +                                          sizeof(sta_ht_cap_new))) {
589 +                                       memcpy(&sta->sta.ht_cap,
590 +                                              &sta_ht_cap_new,
591 +                                              sizeof(sta_ht_cap_new));
592 +                                       rate_control_rate_update(local, sband,
593 +                                                       sta,
594 +                                                       IEEE80211_RC_HT_CHANGED,
595 +                                                       channel_type);
596 +                               }
597 +                       }
598 +               }
599  
600                 rcu_read_unlock();
601         }
602 @@ -898,10 +957,15 @@ int ieee80211_ibss_join(struct ieee80211
603         struct sk_buff *skb;
604  
605         skb = dev_alloc_skb(sdata->local->hw.extra_tx_headroom +
606 -                           36 /* bitrates */ +
607 -                           34 /* SSID */ +
608 -                           3  /* DS params */ +
609 -                           4  /* IBSS params */ +
610 +                           sizeof(struct ieee80211_hdr_3addr) +
611 +                           12 /* struct ieee80211_mgmt.u.beacon */ +
612 +                           2 + IEEE80211_MAX_SSID_LEN /* max SSID */ +
613 +                           2 + 8 /* max Supported Rates */ +
614 +                           3 /* max DS params */ +
615 +                           4 /* IBSS params */ +
616 +                           2 + (IEEE80211_MAX_SUPP_RATES - 8) +
617 +                           2 + sizeof(struct ieee80211_ht_cap) +
618 +                           2 + sizeof(struct ieee80211_ht_info) +
619                             params->ie_len);
620         if (!skb)
621                 return -ENOMEM;
622 @@ -922,13 +986,15 @@ int ieee80211_ibss_join(struct ieee80211
623         sdata->vif.bss_conf.beacon_int = params->beacon_interval;
624  
625         sdata->u.ibss.channel = params->channel;
626 +       sdata->u.ibss.channel_type = params->channel_type;
627         sdata->u.ibss.fixed_channel = params->channel_fixed;
628  
629         /* fix ourselves to that channel now already */
630         if (params->channel_fixed) {
631                 sdata->local->oper_channel = params->channel;
632 -               WARN_ON(!ieee80211_set_channel_type(sdata->local, sdata,
633 -                                                   NL80211_CHAN_NO_HT));
634 +               if (!ieee80211_set_channel_type(sdata->local, sdata,
635 +                                              params->channel_type))
636 +                       return -EINVAL;
637         }
638  
639         if (params->ie) {
640 --- a/net/mac80211/ieee80211_i.h
641 +++ b/net/mac80211/ieee80211_i.h
642 @@ -470,6 +470,7 @@ struct ieee80211_if_ibss {
643         u8 ssid_len, ie_len;
644         u8 *ie;
645         struct ieee80211_channel *channel;
646 +       enum nl80211_channel_type channel_type;
647  
648         unsigned long ibss_join_req;
649         /* probe response/beacon for IBSS */
650 --- a/net/mac80211/iface.c
651 +++ b/net/mac80211/iface.c
652 @@ -178,7 +178,6 @@ static int ieee80211_do_open(struct net_
653  {
654         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
655         struct ieee80211_local *local = sdata->local;
656 -       struct sta_info *sta;
657         u32 changed = 0;
658         int res;
659         u32 hw_reconf_flags = 0;
660 @@ -309,27 +308,6 @@ static int ieee80211_do_open(struct net_
661  
662         set_bit(SDATA_STATE_RUNNING, &sdata->state);
663  
664 -       if (sdata->vif.type == NL80211_IFTYPE_WDS) {
665 -               /* Create STA entry for the WDS peer */
666 -               sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
667 -                                    GFP_KERNEL);
668 -               if (!sta) {
669 -                       res = -ENOMEM;
670 -                       goto err_del_interface;
671 -               }
672 -
673 -               /* no atomic bitop required since STA is not live yet */
674 -               set_sta_flag(sta, WLAN_STA_AUTHORIZED);
675 -
676 -               res = sta_info_insert(sta);
677 -               if (res) {
678 -                       /* STA has been freed */
679 -                       goto err_del_interface;
680 -               }
681 -
682 -               rate_control_rate_init(sta);
683 -       }
684 -
685         /*
686          * set_multicast_list will be invoked by the networking core
687          * which will check whether any increments here were done in
688 @@ -356,8 +334,7 @@ static int ieee80211_do_open(struct net_
689         netif_tx_start_all_queues(dev);
690  
691         return 0;
692 - err_del_interface:
693 -       drv_remove_interface(local, sdata);
694 +
695   err_stop:
696         if (!local->open_count)
697                 drv_stop(local);
698 @@ -732,6 +709,70 @@ static void ieee80211_if_setup(struct ne
699         dev->destructor = free_netdev;
700  }
701  
702 +static void ieee80211_wds_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
703 +                                        struct sk_buff *skb)
704 +{
705 +       struct ieee80211_local *local = sdata->local;
706 +       struct ieee80211_rx_status *rx_status;
707 +       struct ieee802_11_elems elems;
708 +       struct ieee80211_mgmt *mgmt;
709 +       struct sta_info *sta;
710 +       size_t baselen;
711 +       u32 rates = 0;
712 +       u16 stype;
713 +       bool new = false;
714 +       enum ieee80211_band band = local->hw.conf.channel->band;
715 +       struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
716 +
717 +       rx_status = IEEE80211_SKB_RXCB(skb);
718 +       mgmt = (struct ieee80211_mgmt *) skb->data;
719 +       stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
720 +
721 +       if (stype != IEEE80211_STYPE_BEACON)
722 +               return;
723 +
724 +       baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
725 +       if (baselen > skb->len)
726 +               return;
727 +
728 +       ieee802_11_parse_elems(mgmt->u.probe_resp.variable,
729 +                              skb->len - baselen, &elems);
730 +
731 +       rates = ieee80211_sta_get_rates(local, &elems, band);
732 +
733 +       rcu_read_lock();
734 +
735 +       sta = sta_info_get(sdata, sdata->u.wds.remote_addr);
736 +
737 +       if (!sta) {
738 +               rcu_read_unlock();
739 +               sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
740 +                                    GFP_KERNEL);
741 +               if (!sta)
742 +                       return;
743 +
744 +               new = true;
745 +       }
746 +
747 +       sta->last_rx = jiffies;
748 +       sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
749 +
750 +       if (elems.ht_cap_elem)
751 +               ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
752 +                               elems.ht_cap_elem, &sta->sta.ht_cap);
753 +
754 +       if (elems.wmm_param)
755 +               set_sta_flag(sta, WLAN_STA_WME);
756 +
757 +       if (new) {
758 +               set_sta_flag(sta, WLAN_STA_AUTHORIZED);
759 +               rate_control_rate_init(sta);
760 +               sta_info_insert_rcu(sta);
761 +       }
762 +
763 +       rcu_read_unlock();
764 +}
765 +
766  static void ieee80211_iface_work(struct work_struct *work)
767  {
768         struct ieee80211_sub_if_data *sdata =
769 @@ -836,6 +877,9 @@ static void ieee80211_iface_work(struct 
770                                 break;
771                         ieee80211_mesh_rx_queued_mgmt(sdata, skb);
772                         break;
773 +               case NL80211_IFTYPE_WDS:
774 +                       ieee80211_wds_rx_queued_mgmt(sdata, skb);
775 +                       break;
776                 default:
777                         WARN(1, "frame for unexpected interface type");
778                         break;
779 --- a/net/mac80211/mlme.c
780 +++ b/net/mac80211/mlme.c
781 @@ -1359,9 +1359,6 @@ static void __ieee80211_connection_loss(
782         ieee80211_set_disassoc(sdata, true, true);
783         mutex_unlock(&ifmgd->mtx);
784  
785 -       mutex_lock(&local->mtx);
786 -       ieee80211_recalc_idle(local);
787 -       mutex_unlock(&local->mtx);
788         /*
789          * must be outside lock due to cfg80211,
790          * but that's not a problem.
791 @@ -1370,6 +1367,10 @@ static void __ieee80211_connection_loss(
792                                        IEEE80211_STYPE_DEAUTH,
793                                        WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
794                                        NULL, true);
795 +
796 +       mutex_lock(&local->mtx);
797 +       ieee80211_recalc_idle(local);
798 +       mutex_unlock(&local->mtx);
799  }
800  
801  void ieee80211_beacon_connection_loss_work(struct work_struct *work)
802 @@ -2136,9 +2137,6 @@ static void ieee80211_sta_connection_los
803  
804         ieee80211_set_disassoc(sdata, true, true);
805         mutex_unlock(&ifmgd->mtx);
806 -       mutex_lock(&local->mtx);
807 -       ieee80211_recalc_idle(local);
808 -       mutex_unlock(&local->mtx);
809         /*
810          * must be outside lock due to cfg80211,
811          * but that's not a problem.
812 @@ -2146,6 +2144,11 @@ static void ieee80211_sta_connection_los
813         ieee80211_send_deauth_disassoc(sdata, bssid,
814                         IEEE80211_STYPE_DEAUTH, reason,
815                         NULL, true);
816 +
817 +       mutex_lock(&local->mtx);
818 +       ieee80211_recalc_idle(local);
819 +       mutex_unlock(&local->mtx);
820 +
821         mutex_lock(&ifmgd->mtx);
822  }
823  
824 --- a/net/mac80211/offchannel.c
825 +++ b/net/mac80211/offchannel.c
826 @@ -212,8 +212,6 @@ static void ieee80211_hw_roc_start(struc
827                 return;
828         }
829  
830 -       ieee80211_recalc_idle(local);
831 -
832         if (local->hw_roc_skb) {
833                 sdata = IEEE80211_DEV_TO_SUB_IF(local->hw_roc_dev);
834                 ieee80211_tx_skb(sdata, local->hw_roc_skb);
835 @@ -227,6 +225,8 @@ static void ieee80211_hw_roc_start(struc
836                                           GFP_KERNEL);
837         }
838  
839 +       ieee80211_recalc_idle(local);
840 +
841         mutex_unlock(&local->mtx);
842  }
843  
844 --- a/net/mac80211/rx.c
845 +++ b/net/mac80211/rx.c
846 @@ -2250,7 +2250,9 @@ ieee80211_rx_h_action(struct ieee80211_r
847                 if (sdata->vif.type != NL80211_IFTYPE_STATION &&
848                     sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
849                     sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
850 -                   sdata->vif.type != NL80211_IFTYPE_AP)
851 +                   sdata->vif.type != NL80211_IFTYPE_AP &&
852 +                   sdata->vif.type != NL80211_IFTYPE_ADHOC &&
853 +                   sdata->vif.type != NL80211_IFTYPE_WDS)
854                         break;
855  
856                 /* verify action_code is present */
857 @@ -2465,13 +2467,14 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_
858  
859         if (!ieee80211_vif_is_mesh(&sdata->vif) &&
860             sdata->vif.type != NL80211_IFTYPE_ADHOC &&
861 -           sdata->vif.type != NL80211_IFTYPE_STATION)
862 +           sdata->vif.type != NL80211_IFTYPE_STATION &&
863 +           sdata->vif.type != NL80211_IFTYPE_WDS)
864                 return RX_DROP_MONITOR;
865  
866         switch (stype) {
867         case cpu_to_le16(IEEE80211_STYPE_BEACON):
868         case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
869 -               /* process for all: mesh, mlme, ibss */
870 +               /* process for all: mesh, mlme, ibss, wds */
871                 break;
872         case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
873         case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
874 @@ -2818,10 +2821,16 @@ static int prepare_for_handlers(struct i
875                 }
876                 break;
877         case NL80211_IFTYPE_WDS:
878 -               if (bssid || !ieee80211_is_data(hdr->frame_control))
879 -                       return 0;
880                 if (compare_ether_addr(sdata->u.wds.remote_addr, hdr->addr2))
881                         return 0;
882 +
883 +               if (ieee80211_is_data(hdr->frame_control) ||
884 +                   ieee80211_is_action(hdr->frame_control)) {
885 +                       if (compare_ether_addr(sdata->vif.addr, hdr->addr1))
886 +                               return 0;
887 +               } else if (!ieee80211_is_beacon(hdr->frame_control))
888 +                       return 0;
889 +
890                 break;
891         default:
892                 /* should never get here */
893 --- a/net/mac80211/sta_info.h
894 +++ b/net/mac80211/sta_info.h
895 @@ -32,7 +32,6 @@
896   *     frames.
897   * @WLAN_STA_ASSOC_AP: We're associated to that station, it is an AP.
898   * @WLAN_STA_WME: Station is a QoS-STA.
899 - * @WLAN_STA_WDS: Station is one of our WDS peers.
900   * @WLAN_STA_CLEAR_PS_FILT: Clear PS filter in hardware (using the
901   *     IEEE80211_TX_CTL_CLEAR_PS_FILT control flag) when the next
902   *     frame to this station is transmitted.
903 @@ -62,7 +61,6 @@ enum ieee80211_sta_info_flags {
904         WLAN_STA_SHORT_PREAMBLE,
905         WLAN_STA_ASSOC_AP,
906         WLAN_STA_WME,
907 -       WLAN_STA_WDS,
908         WLAN_STA_CLEAR_PS_FILT,
909         WLAN_STA_MFP,
910         WLAN_STA_BLOCK_BA,
911 --- a/net/wireless/chan.c
912 +++ b/net/wireless/chan.c
913 @@ -44,9 +44,9 @@ rdev_freq_to_chan(struct cfg80211_regist
914         return chan;
915  }
916  
917 -static bool can_beacon_sec_chan(struct wiphy *wiphy,
918 -                               struct ieee80211_channel *chan,
919 -                               enum nl80211_channel_type channel_type)
920 +bool cfg80211_can_beacon_sec_chan(struct wiphy *wiphy,
921 +                                 struct ieee80211_channel *chan,
922 +                                 enum nl80211_channel_type channel_type)
923  {
924         struct ieee80211_channel *sec_chan;
925         int diff;
926 @@ -75,6 +75,7 @@ static bool can_beacon_sec_chan(struct w
927  
928         return true;
929  }
930 +EXPORT_SYMBOL(cfg80211_can_beacon_sec_chan);
931  
932  int cfg80211_set_freq(struct cfg80211_registered_device *rdev,
933                       struct wireless_dev *wdev, int freq,
934 @@ -109,8 +110,8 @@ int cfg80211_set_freq(struct cfg80211_re
935                 switch (channel_type) {
936                 case NL80211_CHAN_HT40PLUS:
937                 case NL80211_CHAN_HT40MINUS:
938 -                       if (!can_beacon_sec_chan(&rdev->wiphy, chan,
939 -                                                channel_type)) {
940 +                       if (!cfg80211_can_beacon_sec_chan(&rdev->wiphy, chan,
941 +                                                         channel_type)) {