TEST(TDLS_PEER_AUTH), TEST(4ADDR_EVENT),
--- a/net/mac80211/iface.c
+++ b/net/mac80211/iface.c
+@@ -78,7 +78,7 @@ void ieee80211_recalc_txpower(struct iee
+ ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
+ }
+
+-static u32 ieee80211_idle_off(struct ieee80211_local *local)
++u32 ieee80211_idle_off(struct ieee80211_local *local)
+ {
+ if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
+ return 0;
@@ -107,7 +107,7 @@ void ieee80211_recalc_idle(struct ieee80
lockdep_assert_held(&local->mtx);
u32 changed = 0;
int res;
u32 hw_reconf_flags = 0;
-@@ -595,30 +594,8 @@ int ieee80211_do_open(struct wireless_de
+@@ -541,6 +540,9 @@ int ieee80211_do_open(struct wireless_de
+
+ ieee80211_adjust_monitor_flags(sdata, 1);
+ ieee80211_configure_filter(local);
++ mutex_lock(&local->mtx);
++ ieee80211_recalc_idle(local);
++ mutex_unlock(&local->mtx);
+
+ netif_carrier_on(dev);
+ break;
+@@ -595,30 +597,8 @@ int ieee80211_do_open(struct wireless_de
set_bit(SDATA_STATE_RUNNING, &sdata->state);
/*
* set_multicast_list will be invoked by the networking core
-@@ -1022,6 +999,72 @@ static void ieee80211_if_setup(struct ne
+@@ -817,6 +797,9 @@ static void ieee80211_do_stop(struct iee
+
+ ieee80211_adjust_monitor_flags(sdata, -1);
+ ieee80211_configure_filter(local);
++ mutex_lock(&local->mtx);
++ ieee80211_recalc_idle(local);
++ mutex_unlock(&local->mtx);
+ break;
+ case NL80211_IFTYPE_P2P_DEVICE:
+ /* relies on synchronize_rcu() below */
+@@ -1022,6 +1005,72 @@ static void ieee80211_if_setup(struct ne
dev->destructor = free_netdev;
}
static void ieee80211_iface_work(struct work_struct *work)
{
struct ieee80211_sub_if_data *sdata =
-@@ -1126,6 +1169,9 @@ static void ieee80211_iface_work(struct
+@@ -1126,6 +1175,9 @@ static void ieee80211_iface_work(struct
break;
ieee80211_mesh_rx_queued_mgmt(sdata, skb);
break;
BIT(NL80211_IFTYPE_WDS);
rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
+--- a/net/mac80211/rc80211_minstrel_ht.c
++++ b/net/mac80211/rc80211_minstrel_ht.c
+@@ -26,11 +26,11 @@
+ /* Number of symbols for a packet with (bps) bits per symbol */
+ #define MCS_NSYMS(bps) ((MCS_NBITS + (bps) - 1) / (bps))
+
+-/* Transmission time for a packet containing (syms) symbols */
++/* Transmission time (nanoseconds) for a packet containing (syms) symbols */
+ #define MCS_SYMBOL_TIME(sgi, syms) \
+ (sgi ? \
+- ((syms) * 18 + 4) / 5 : /* syms * 3.6 us */ \
+- (syms) << 2 /* syms * 4 us */ \
++ ((syms) * 18000 + 4000) / 5 : /* syms * 3.6 us */ \
++ ((syms) * 1000) << 2 /* syms * 4 us */ \
+ )
+
+ /* Transmit duration for the raw data part of an average sized packet */
+@@ -64,9 +64,9 @@
+ }
+
+ #define CCK_DURATION(_bitrate, _short, _len) \
+- (10 /* SIFS */ + \
++ (1000 * (10 /* SIFS */ + \
+ (_short ? 72 + 24 : 144 + 48 ) + \
+- (8 * (_len + 4) * 10) / (_bitrate))
++ (8 * (_len + 4) * 10) / (_bitrate)))
+
+ #define CCK_ACK_DURATION(_bitrate, _short) \
+ (CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) + \
+@@ -211,20 +211,32 @@ static void
+ minstrel_ht_calc_tp(struct minstrel_ht_sta *mi, int group, int rate)
+ {
+ struct minstrel_rate_stats *mr;
+- unsigned int usecs = 0;
++ unsigned int nsecs = 0;
++ unsigned int tp;
++ unsigned int prob;
+
+ mr = &mi->groups[group].rates[rate];
++ prob = mr->probability;
+
+- if (mr->probability < MINSTREL_FRAC(1, 10)) {
++ if (prob < MINSTREL_FRAC(1, 10)) {
+ mr->cur_tp = 0;
+ return;
+ }
+
++ /*
++ * For the throughput calculation, limit the probability value to 90% to
++ * account for collision related packet error rate fluctuation
++ */
++ if (prob > MINSTREL_FRAC(9, 10))
++ prob = MINSTREL_FRAC(9, 10);
++
+ if (group != MINSTREL_CCK_GROUP)
+- usecs = mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
++ nsecs = 1000 * mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
+
+- usecs += minstrel_mcs_groups[group].duration[rate];
+- mr->cur_tp = MINSTREL_TRUNC((1000000 / usecs) * mr->probability);
++ nsecs += minstrel_mcs_groups[group].duration[rate];
++ tp = 1000000 * ((mr->probability * 1000) / nsecs);
++
++ mr->cur_tp = MINSTREL_TRUNC(tp);
+ }
+
+ /*
+@@ -308,8 +320,8 @@ minstrel_ht_update_stats(struct minstrel
+ }
+ }
+
+- /* try to sample up to half of the available rates during each interval */
+- mi->sample_count *= 4;
++ /* try to sample all available rates during each interval */
++ mi->sample_count *= 8;
+
+ cur_prob = 0;
+ cur_prob_tp = 0;
+@@ -320,20 +332,13 @@ minstrel_ht_update_stats(struct minstrel
+ if (!mg->supported)
+ continue;
+
+- mr = minstrel_get_ratestats(mi, mg->max_prob_rate);
+- if (cur_prob_tp < mr->cur_tp &&
+- minstrel_mcs_groups[group].streams == 1) {
+- mi->max_prob_rate = mg->max_prob_rate;
+- cur_prob = mr->cur_prob;
+- cur_prob_tp = mr->cur_tp;
+- }
+-
+ mr = minstrel_get_ratestats(mi, mg->max_tp_rate);
+ if (cur_tp < mr->cur_tp) {
+ mi->max_tp_rate2 = mi->max_tp_rate;
+ cur_tp2 = cur_tp;
+ mi->max_tp_rate = mg->max_tp_rate;
+ cur_tp = mr->cur_tp;
++ mi->max_prob_streams = minstrel_mcs_groups[group].streams - 1;
+ }
+
+ mr = minstrel_get_ratestats(mi, mg->max_tp_rate2);
+@@ -343,6 +348,23 @@ minstrel_ht_update_stats(struct minstrel
+ }
+ }
+
++ if (mi->max_prob_streams < 1)
++ mi->max_prob_streams = 1;
++
++ for (group = 0; group < ARRAY_SIZE(minstrel_mcs_groups); group++) {
++ mg = &mi->groups[group];
++ if (!mg->supported)
++ continue;
++ mr = minstrel_get_ratestats(mi, mg->max_prob_rate);
++ if (cur_prob_tp < mr->cur_tp &&
++ minstrel_mcs_groups[group].streams <= mi->max_prob_streams) {
++ mi->max_prob_rate = mg->max_prob_rate;
++ cur_prob = mr->cur_prob;
++ cur_prob_tp = mr->cur_tp;
++ }
++ }
++
++
+ mi->stats_update = jiffies;
+ }
+
+@@ -467,7 +489,7 @@ minstrel_ht_tx_status(void *priv, struct
+
+ if (!mi->sample_wait && !mi->sample_tries && mi->sample_count > 0) {
+ mi->sample_wait = 16 + 2 * MINSTREL_TRUNC(mi->avg_ampdu_len);
+- mi->sample_tries = 2;
++ mi->sample_tries = 1;
+ mi->sample_count--;
+ }
+
+@@ -536,7 +558,7 @@ minstrel_calc_retransmit(struct minstrel
+ mr->retry_updated = true;
+
+ group = &minstrel_mcs_groups[index / MCS_GROUP_RATES];
+- tx_time_data = group->duration[index % MCS_GROUP_RATES] * ampdu_len;
++ tx_time_data = group->duration[index % MCS_GROUP_RATES] * ampdu_len / 1000;
+
+ /* Contention time for first 2 tries */
+ ctime = (t_slot * cw) >> 1;
+@@ -616,6 +638,7 @@ minstrel_get_sample_rate(struct minstrel
+ {
+ struct minstrel_rate_stats *mr;
+ struct minstrel_mcs_group_data *mg;
++ unsigned int sample_dur, sample_group;
+ int sample_idx = 0;
+
+ if (mi->sample_wait > 0) {
+@@ -626,39 +649,46 @@ minstrel_get_sample_rate(struct minstrel
+ if (!mi->sample_tries)
+ return -1;
+
+- mi->sample_tries--;
+ mg = &mi->groups[mi->sample_group];
+ sample_idx = sample_table[mg->column][mg->index];
+ mr = &mg->rates[sample_idx];
+- sample_idx += mi->sample_group * MCS_GROUP_RATES;
++ sample_group = mi->sample_group;
++ sample_idx += sample_group * MCS_GROUP_RATES;
+ minstrel_next_sample_idx(mi);
+
+ /*
+ * Sampling might add some overhead (RTS, no aggregation)
+ * to the frame. Hence, don't use sampling for the currently
+- * used max TP rate.
++ * used rates.
+ */
+- if (sample_idx == mi->max_tp_rate)
++ if (sample_idx == mi->max_tp_rate ||
++ sample_idx == mi->max_tp_rate2 ||
++ sample_idx == mi->max_prob_rate)
+ return -1;
++
+ /*
+- * When not using MRR, do not sample if the probability is already
+- * higher than 95% to avoid wasting airtime
++ * Do not sample if the probability is already higher than 95%
++ * to avoid wasting airtime.
+ */
+- if (!mp->has_mrr && (mr->probability > MINSTREL_FRAC(95, 100)))
++ if (mr->probability > MINSTREL_FRAC(95, 100))
+ return -1;
+
+ /*
+ * Make sure that lower rates get sampled only occasionally,
+ * if the link is working perfectly.
+ */
+- if (minstrel_get_duration(sample_idx) >
+- minstrel_get_duration(mi->max_tp_rate)) {
++ sample_dur = minstrel_get_duration(sample_idx);
++ if (sample_dur >= minstrel_get_duration(mi->max_tp_rate2) &&
++ (mi->max_prob_streams <
++ minstrel_mcs_groups[sample_group].streams ||
++ sample_dur >= minstrel_get_duration(mi->max_prob_rate))) {
+ if (mr->sample_skipped < 20)
+ return -1;
+
+ if (mi->sample_slow++ > 2)
+ return -1;
+ }
++ mi->sample_tries--;
+
+ return sample_idx;
+ }
+--- a/net/mac80211/rc80211_minstrel_ht.h
++++ b/net/mac80211/rc80211_minstrel_ht.h
+@@ -85,6 +85,7 @@ struct minstrel_ht_sta {
+
+ /* best probability rate */
+ unsigned int max_prob_rate;
++ unsigned int max_prob_streams;
+
+ /* time of last status update */
+ unsigned long stats_update;
+--- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c
++++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
+@@ -1023,6 +1023,7 @@ static bool ar9003_hw_init_cal(struct at
+ AR_PHY_AGC_CONTROL_FLTR_CAL |
+ AR_PHY_AGC_CONTROL_PKDET_CAL;
+
++ /* Use chip chainmask only for calibration */
+ ar9003_hw_set_chain_masks(ah, ah->caps.rx_chainmask, ah->caps.tx_chainmask);
+
+ if (rtt) {
+@@ -1150,6 +1151,9 @@ skip_tx_iqcal:
+ ar9003_hw_rtt_disable(ah);
+ }
+
++ /* Revert chainmask to runtime parameters */
++ ar9003_hw_set_chain_masks(ah, ah->rxchainmask, ah->txchainmask);
++
+ /* Initialize list pointers */
+ ah->cal_list = ah->cal_list_last = ah->cal_list_curr = NULL;
+
+--- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
++++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
+@@ -3606,6 +3606,12 @@ static void ar9003_hw_ant_ctrl_apply(str
+ value = ar9003_hw_ant_ctrl_common_2_get(ah, is2ghz);
+ REG_RMW_FIELD(ah, AR_PHY_SWITCH_COM_2, AR_SWITCH_TABLE_COM2_ALL, value);
+
++ if ((AR_SREV_9462(ah)) && (ah->rxchainmask == 0x2)) {
++ value = ar9003_hw_ant_ctrl_chain_get(ah, 1, is2ghz);
++ REG_RMW_FIELD(ah, switch_chain_reg[0],
++ AR_SWITCH_TABLE_ALL, value);
++ }
++
+ for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
+ if ((ah->rxchainmask & BIT(chain)) ||
+ (ah->txchainmask & BIT(chain))) {
+@@ -3772,6 +3778,17 @@ static void ar9003_hw_atten_apply(struct
+ AR_PHY_EXT_ATTEN_CTL_2,
+ };
+
++ if ((AR_SREV_9462(ah)) && (ah->rxchainmask == 0x2)) {
++ value = ar9003_hw_atten_chain_get(ah, 1, chan);
++ REG_RMW_FIELD(ah, ext_atten_reg[0],
++ AR_PHY_EXT_ATTEN_CTL_XATTEN1_DB, value);
++
++ value = ar9003_hw_atten_chain_get_margin(ah, 1, chan);
++ REG_RMW_FIELD(ah, ext_atten_reg[0],
++ AR_PHY_EXT_ATTEN_CTL_XATTEN1_MARGIN,
++ value);
++ }
++
+ /* Test value. if 0 then attenuation is unused. Don't load anything. */
+ for (i = 0; i < 3; i++) {
+ if (ah->txchainmask & BIT(i)) {
+--- a/drivers/net/wireless/ath/ath9k/link.c
++++ b/drivers/net/wireless/ath/ath9k/link.c
+@@ -28,21 +28,21 @@ void ath_tx_complete_poll_work(struct wo
+ int i;
+ bool needreset = false;
+
+- for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
+- if (ATH_TXQ_SETUP(sc, i)) {
+- txq = &sc->tx.txq[i];
+- ath_txq_lock(sc, txq);
+- if (txq->axq_depth) {
+- if (txq->axq_tx_inprogress) {
+- needreset = true;
+- ath_txq_unlock(sc, txq);
+- break;
+- } else {
+- txq->axq_tx_inprogress = true;
+- }
++ for (i = 0; i < IEEE80211_NUM_ACS; i++) {
++ txq = sc->tx.txq_map[i];
++
++ ath_txq_lock(sc, txq);
++ if (txq->axq_depth) {
++ if (txq->axq_tx_inprogress) {
++ needreset = true;
++ ath_txq_unlock(sc, txq);
++ break;
++ } else {
++ txq->axq_tx_inprogress = true;
+ }
+- ath_txq_unlock_complete(sc, txq);
+ }
++ ath_txq_unlock_complete(sc, txq);
++ }
+
+ if (needreset) {
+ ath_dbg(ath9k_hw_common(sc->sc_ah), RESET,
+--- a/net/mac80211/sta_info.c
++++ b/net/mac80211/sta_info.c
+@@ -766,6 +766,7 @@ int __must_check __sta_info_destroy(stru
+ struct ieee80211_local *local;
+ struct ieee80211_sub_if_data *sdata;
+ int ret, i;
++ bool have_key = false;
+
+ might_sleep();
+
+@@ -793,12 +794,19 @@ int __must_check __sta_info_destroy(stru
+ list_del_rcu(&sta->list);
+
+ mutex_lock(&local->key_mtx);
+- for (i = 0; i < NUM_DEFAULT_KEYS; i++)
++ for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
+ __ieee80211_key_free(key_mtx_dereference(local, sta->gtk[i]));
+- if (sta->ptk)
++ have_key = true;
++ }
++ if (sta->ptk) {
+ __ieee80211_key_free(key_mtx_dereference(local, sta->ptk));
++ have_key = true;
++ }
+ mutex_unlock(&local->key_mtx);
+
++ if (!have_key)
++ synchronize_net();
++
+ sta->dead = true;
+
+ local->num_sta--;
+--- a/net/mac80211/chan.c
++++ b/net/mac80211/chan.c
+@@ -63,6 +63,7 @@ ieee80211_new_chanctx(struct ieee80211_l
+ enum ieee80211_chanctx_mode mode)
+ {
+ struct ieee80211_chanctx *ctx;
++ u32 changed;
+ int err;
+
+ lockdep_assert_held(&local->chanctx_mtx);
+@@ -76,6 +77,13 @@ ieee80211_new_chanctx(struct ieee80211_l
+ ctx->conf.rx_chains_dynamic = 1;
+ ctx->mode = mode;
+
++ /* acquire mutex to prevent idle from changing */
++ mutex_lock(&local->mtx);
++ /* turn idle off *before* setting channel -- some drivers need that */
++ changed = ieee80211_idle_off(local);
++ if (changed)
++ ieee80211_hw_config(local, changed);
++
+ if (!local->use_chanctx) {
+ local->_oper_channel_type =
+ cfg80211_get_chandef_type(chandef);
+@@ -85,14 +93,17 @@ ieee80211_new_chanctx(struct ieee80211_l
+ err = drv_add_chanctx(local, ctx);
+ if (err) {
+ kfree(ctx);
+- return ERR_PTR(err);
++ ctx = ERR_PTR(err);
++
++ ieee80211_recalc_idle(local);
++ goto out;
+ }
+ }
+
++ /* and keep the mutex held until the new chanctx is on the list */
+ list_add_rcu(&ctx->list, &local->chanctx_list);
+
+- mutex_lock(&local->mtx);
+- ieee80211_recalc_idle(local);
++ out:
+ mutex_unlock(&local->mtx);
+
+ return ctx;
+--- a/net/mac80211/ieee80211_i.h
++++ b/net/mac80211/ieee80211_i.h
+@@ -1366,6 +1366,7 @@ int ieee80211_if_change_type(struct ieee
+ enum nl80211_iftype type);
+ void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
+ void ieee80211_remove_interfaces(struct ieee80211_local *local);
++u32 ieee80211_idle_off(struct ieee80211_local *local);
+ void ieee80211_recalc_idle(struct ieee80211_local *local);
+ void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
+ const int offset);
+--- a/drivers/net/wireless/ath/ath9k/htc_drv_init.c
++++ b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
+@@ -799,7 +799,7 @@ static int ath9k_init_firmware_version(s
+ * required version.
+ */
+ if (priv->fw_version_major != MAJOR_VERSION_REQ ||
+- priv->fw_version_minor != MINOR_VERSION_REQ) {
++ priv->fw_version_minor < MINOR_VERSION_REQ) {
+ dev_err(priv->dev, "ath9k_htc: Please upgrade to FW version %d.%d\n",
+ MAJOR_VERSION_REQ, MINOR_VERSION_REQ);
+ return -EINVAL;
+--- a/drivers/net/wireless/ath/ath9k/xmit.c
++++ b/drivers/net/wireless/ath/ath9k/xmit.c
+@@ -516,8 +516,7 @@ static void ath_tx_complete_aggr(struct
+ * not a holding desc.
+ */
+ INIT_LIST_HEAD(&bf_head);
+- if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) ||
+- bf_next != NULL || !bf_last->bf_stale)
++ if (bf_next != NULL || !bf_last->bf_stale)
+ list_move_tail(&bf->list, &bf_head);
+
+ if (!txpending || (tid->state & AGGR_CLEANUP)) {
+@@ -537,8 +536,7 @@ static void ath_tx_complete_aggr(struct
+ !txfail);
+ } else {
+ /* retry the un-acked ones */
+- if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
+- bf->bf_next == NULL && bf_last->bf_stale) {
++ if (bf->bf_next == NULL && bf_last->bf_stale) {
+ struct ath_buf *tbf;
+
+ tbf = ath_clone_txbuf(sc, bf_last);
+@@ -2264,6 +2262,7 @@ void ath_tx_edma_tasklet(struct ath_soft
+ struct ath_txq *txq;
+ struct ath_buf *bf, *lastbf;
+ struct list_head bf_head;
++ struct list_head *fifo_list;
+ int status;
+
+ for (;;) {
+@@ -2291,20 +2290,24 @@ void ath_tx_edma_tasklet(struct ath_soft
+
+ TX_STAT_INC(txq->axq_qnum, txprocdesc);
+
+- if (list_empty(&txq->txq_fifo[txq->txq_tailidx])) {
++ fifo_list = &txq->txq_fifo[txq->txq_tailidx];
++ if (list_empty(fifo_list)) {
+ ath_txq_unlock(sc, txq);
+ return;
+ }
+
+- bf = list_first_entry(&txq->txq_fifo[txq->txq_tailidx],
+- struct ath_buf, list);
++ bf = list_first_entry(fifo_list, struct ath_buf, list);
++ if (bf->bf_stale) {
++ list_del(&bf->list);
++ ath_tx_return_buffer(sc, bf);
++ bf = list_first_entry(fifo_list, struct ath_buf, list);
++ }
++
+ lastbf = bf->bf_lastbf;
+
+ INIT_LIST_HEAD(&bf_head);
+- list_cut_position(&bf_head, &txq->txq_fifo[txq->txq_tailidx],
+- &lastbf->list);
+-
+- if (list_empty(&txq->txq_fifo[txq->txq_tailidx])) {
++ if (list_is_last(&lastbf->list, fifo_list)) {
++ list_splice_tail_init(fifo_list, &bf_head);
+ INCR(txq->txq_tailidx, ATH_TXFIFO_DEPTH);
+
+ if (!list_empty(&txq->axq_q)) {
+@@ -2315,6 +2318,11 @@ void ath_tx_edma_tasklet(struct ath_soft
+ list_splice_tail_init(&txq->axq_q, &bf_q);
+ ath_tx_txqaddbuf(sc, txq, &bf_q, true);
+ }
++ } else {
++ lastbf->bf_stale = true;
++ if (bf != lastbf)
++ list_cut_position(&bf_head, fifo_list,
++ lastbf->list.prev);
+ }
+
+ ath_tx_process_buffer(sc, txq, &ts, bf, &bf_head);
+--- a/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h
++++ b/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h
+@@ -519,7 +519,7 @@ static const u32 ar9580_1p0_mac_core[][2
+ {0x00008258, 0x00000000},
+ {0x0000825c, 0x40000000},
+ {0x00008260, 0x00080922},
+- {0x00008264, 0x9bc00010},
++ {0x00008264, 0x9d400010},
+ {0x00008268, 0xffffffff},
+ {0x0000826c, 0x0000ffff},
+ {0x00008270, 0x00000000},
+--- a/net/mac80211/mlme.c
++++ b/net/mac80211/mlme.c
+@@ -3955,8 +3955,16 @@ int ieee80211_mgd_auth(struct ieee80211_
+ /* prep auth_data so we don't go into idle on disassoc */
+ ifmgd->auth_data = auth_data;
+
+- if (ifmgd->associated)
+- ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
++ if (ifmgd->associated) {
++ u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
++
++ ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
++ WLAN_REASON_UNSPECIFIED,
++ false, frame_buf);
++
++ __cfg80211_send_deauth(sdata->dev, frame_buf,
++ sizeof(frame_buf));
++ }
+
+ sdata_info(sdata, "authenticate with %pM\n", req->bss->bssid);
+
+@@ -4016,8 +4024,16 @@ int ieee80211_mgd_assoc(struct ieee80211
+
+ mutex_lock(&ifmgd->mtx);
+
+- if (ifmgd->associated)
+- ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
++ if (ifmgd->associated) {
++ u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
++
++ ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
++ WLAN_REASON_UNSPECIFIED,
++ false, frame_buf);
++
++ __cfg80211_send_deauth(sdata->dev, frame_buf,
++ sizeof(frame_buf));
++ }
+
+ if (ifmgd->auth_data && !ifmgd->auth_data->done) {
+ err = -EBUSY;
projects / openwrt / svn-archive / archive.git / blobdiff