projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ath9k: change the BSSID mask calculation to fix setting arbitrary MAC address on...
[openwrt/openwrt.git] / package / mac80211 / patches / 300-pending_work.patch
1 --- a/drivers/net/wireless/ath/ath9k/common.h
2 +++ b/drivers/net/wireless/ath/ath9k/common.h
3 @@ -27,7 +27,7 @@
4 #define WME_MAX_BA WME_BA_BMP_SIZE
5 #define ATH_TID_MAX_BUFS (2 * WME_MAX_BA)
6
7 -#define ATH_RSSI_DUMMY_MARKER 0x127
8 +#define ATH_RSSI_DUMMY_MARKER 127
9 #define ATH_RSSI_LPF_LEN 10
10 #define RSSI_LPF_THRESHOLD -20
11 #define ATH_RSSI_EP_MULTIPLIER (1<<7)
12 --- a/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
13 +++ b/drivers/net/wireless/ath/ath9k/htc_drv_txrx.c
14 @@ -1067,15 +1067,19 @@ static bool ath9k_rx_prepare(struct ath9
15
16 last_rssi = priv->rx.last_rssi;
17
18 - if (likely(last_rssi != ATH_RSSI_DUMMY_MARKER))
19 - rxbuf->rxstatus.rs_rssi = ATH_EP_RND(last_rssi,
20 - ATH_RSSI_EP_MULTIPLIER);
21 + if (ieee80211_is_beacon(hdr->frame_control) &&
22 + !is_zero_ether_addr(common->curbssid) &&
23 + ether_addr_equal(hdr->addr3, common->curbssid)) {
24 + s8 rssi = rxbuf->rxstatus.rs_rssi;
25
26 - if (rxbuf->rxstatus.rs_rssi < 0)
27 - rxbuf->rxstatus.rs_rssi = 0;
28 + if (likely(last_rssi != ATH_RSSI_DUMMY_MARKER))
29 + rssi = ATH_EP_RND(last_rssi, ATH_RSSI_EP_MULTIPLIER);
30
31 - if (ieee80211_is_beacon(fc))
32 - priv->ah->stats.avgbrssi = rxbuf->rxstatus.rs_rssi;
33 + if (rssi < 0)
34 + rssi = 0;
35 +
36 + priv->ah->stats.avgbrssi = rssi;
37 + }
38
39 rx_status->mactime = be64_to_cpu(rxbuf->rxstatus.rs_tstamp);
40 rx_status->band = hw->conf.channel->band;
41 --- a/include/linux/ieee80211.h
42 +++ b/include/linux/ieee80211.h
43 @@ -185,7 +185,7 @@ struct ieee80211_hdr {
44 u8 addr3[6];
45 __le16 seq_ctrl;
46 u8 addr4[6];
47 -} __packed;
48 +} __packed __aligned(2);
49
50 struct ieee80211_hdr_3addr {
51 __le16 frame_control;
52 @@ -194,7 +194,7 @@ struct ieee80211_hdr_3addr {
53 u8 addr2[6];
54 u8 addr3[6];
55 __le16 seq_ctrl;
56 -} __packed;
57 +} __packed __aligned(2);
58
59 struct ieee80211_qos_hdr {
60 __le16 frame_control;
61 @@ -204,7 +204,7 @@ struct ieee80211_qos_hdr {
62 u8 addr3[6];
63 __le16 seq_ctrl;
64 __le16 qos_ctrl;
65 -} __packed;
66 +} __packed __aligned(2);
67
68 /**
69 * ieee80211_has_tods - check if IEEE80211_FCTL_TODS is set
70 @@ -581,7 +581,7 @@ struct ieee80211s_hdr {
71 __le32 seqnum;
72 u8 eaddr1[6];
73 u8 eaddr2[6];
74 -} __packed;
75 +} __packed __aligned(2);
76
77 /* Mesh flags */
78 #define MESH_FLAGS_AE_A4 0x1
79 @@ -875,7 +875,7 @@ struct ieee80211_mgmt {
80 } u;
81 } __packed action;
82 } u;
83 -} __packed;
84 +} __packed __aligned(2);
85
86 /* Supported Rates value encodings in 802.11n-2009 7.3.2.2 */
87 #define BSS_MEMBERSHIP_SELECTOR_HT_PHY 127
88 @@ -906,20 +906,20 @@ struct ieee80211_rts {
89 __le16 duration;
90 u8 ra[6];
91 u8 ta[6];
92 -} __packed;
93 +} __packed __aligned(2);
94
95 struct ieee80211_cts {
96 __le16 frame_control;
97 __le16 duration;
98 u8 ra[6];
99 -} __packed;
100 +} __packed __aligned(2);
101
102 struct ieee80211_pspoll {
103 __le16 frame_control;
104 __le16 aid;
105 u8 bssid[6];
106 u8 ta[6];
107 -} __packed;
108 +} __packed __aligned(2);
109
110 /* TDLS */
111
112 --- a/net/mac80211/agg-rx.c
113 +++ b/net/mac80211/agg-rx.c
114 @@ -204,6 +204,8 @@ static void ieee80211_send_addba_resp(st
115 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
116 else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
117 memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
118 + else if (sdata->vif.type == NL80211_IFTYPE_WDS)
119 + memcpy(mgmt->bssid, da, ETH_ALEN);
120
121 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
122 IEEE80211_STYPE_ACTION);
123 --- a/net/mac80211/agg-tx.c
124 +++ b/net/mac80211/agg-tx.c
125 @@ -81,7 +81,8 @@ static void ieee80211_send_addba_request
126 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
127 if (sdata->vif.type == NL80211_IFTYPE_AP ||
128 sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
129 - sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
130 + sdata->vif.type == NL80211_IFTYPE_MESH_POINT ||
131 + sdata->vif.type == NL80211_IFTYPE_WDS)
132 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
133 else if (sdata->vif.type == NL80211_IFTYPE_STATION)
134 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
135 @@ -527,6 +528,7 @@ int ieee80211_start_tx_ba_session(struct
136 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
137 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
138 sdata->vif.type != NL80211_IFTYPE_AP &&
139 + sdata->vif.type != NL80211_IFTYPE_WDS &&
140 sdata->vif.type != NL80211_IFTYPE_ADHOC)
141 return -EINVAL;
142
143 --- a/net/mac80211/debugfs_sta.c
144 +++ b/net/mac80211/debugfs_sta.c
145 @@ -65,11 +65,11 @@ static ssize_t sta_flags_read(struct fil
146 test_sta_flag(sta, WLAN_STA_##flg) ? #flg "\n" : ""
147
148 int res = scnprintf(buf, sizeof(buf),
149 - "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
150 + "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
151 TEST(AUTH), TEST(ASSOC), TEST(PS_STA),
152 TEST(PS_DRIVER), TEST(AUTHORIZED),
153 TEST(SHORT_PREAMBLE),
154 - TEST(WME), TEST(WDS), TEST(CLEAR_PS_FILT),
155 + TEST(WME), TEST(CLEAR_PS_FILT),
156 TEST(MFP), TEST(BLOCK_BA), TEST(PSPOLL),
157 TEST(UAPSD), TEST(SP), TEST(TDLS_PEER),
158 TEST(TDLS_PEER_AUTH), TEST(4ADDR_EVENT),
159 --- a/net/mac80211/iface.c
160 +++ b/net/mac80211/iface.c
161 @@ -78,7 +78,7 @@ void ieee80211_recalc_txpower(struct iee
162 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_TXPOWER);
163 }
164
165 -static u32 ieee80211_idle_off(struct ieee80211_local *local)
166 +u32 ieee80211_idle_off(struct ieee80211_local *local)
167 {
168 if (!(local->hw.conf.flags & IEEE80211_CONF_IDLE))
169 return 0;
170 @@ -107,7 +107,7 @@ void ieee80211_recalc_idle(struct ieee80
171
172 lockdep_assert_held(&local->mtx);
173
174 - active = !list_empty(&local->chanctx_list);
175 + active = !list_empty(&local->chanctx_list) || local->monitors;
176
177 if (!local->ops->remain_on_channel) {
178 list_for_each_entry(roc, &local->roc_list, list) {
179 @@ -436,7 +436,6 @@ int ieee80211_do_open(struct wireless_de
180 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
181 struct net_device *dev = wdev->netdev;
182 struct ieee80211_local *local = sdata->local;
183 - struct sta_info *sta;
184 u32 changed = 0;
185 int res;
186 u32 hw_reconf_flags = 0;
187 @@ -541,6 +540,9 @@ int ieee80211_do_open(struct wireless_de
188
189 ieee80211_adjust_monitor_flags(sdata, 1);
190 ieee80211_configure_filter(local);
191 + mutex_lock(&local->mtx);
192 + ieee80211_recalc_idle(local);
193 + mutex_unlock(&local->mtx);
194
195 netif_carrier_on(dev);
196 break;
197 @@ -595,30 +597,8 @@ int ieee80211_do_open(struct wireless_de
198
199 set_bit(SDATA_STATE_RUNNING, &sdata->state);
200
201 - if (sdata->vif.type == NL80211_IFTYPE_WDS) {
202 - /* Create STA entry for the WDS peer */
203 - sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
204 - GFP_KERNEL);
205 - if (!sta) {
206 - res = -ENOMEM;
207 - goto err_del_interface;
208 - }
209 -
210 - sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
211 - sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
212 - sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
213 -
214 - res = sta_info_insert(sta);
215 - if (res) {
216 - /* STA has been freed */
217 - goto err_del_interface;
218 - }
219 -
220 - rate_control_rate_init(sta);
221 - netif_carrier_on(dev);
222 - } else if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) {
223 + if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE)
224 rcu_assign_pointer(local->p2p_sdata, sdata);
225 - }
226
227 /*
228 * set_multicast_list will be invoked by the networking core
229 @@ -817,6 +797,9 @@ static void ieee80211_do_stop(struct iee
230
231 ieee80211_adjust_monitor_flags(sdata, -1);
232 ieee80211_configure_filter(local);
233 + mutex_lock(&local->mtx);
234 + ieee80211_recalc_idle(local);
235 + mutex_unlock(&local->mtx);
236 break;
237 case NL80211_IFTYPE_P2P_DEVICE:
238 /* relies on synchronize_rcu() below */
239 @@ -1022,6 +1005,72 @@ static void ieee80211_if_setup(struct ne
240 dev->destructor = free_netdev;
241 }
242
243 +static void ieee80211_wds_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
244 + struct sk_buff *skb)
245 +{
246 + struct ieee80211_local *local = sdata->local;
247 + struct ieee80211_rx_status *rx_status;
248 + struct ieee802_11_elems elems;
249 + struct ieee80211_mgmt *mgmt;
250 + struct sta_info *sta;
251 + size_t baselen;
252 + u32 rates = 0;
253 + u16 stype;
254 + bool new = false;
255 + enum ieee80211_band band = local->hw.conf.channel->band;
256 + struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
257 +
258 + rx_status = IEEE80211_SKB_RXCB(skb);
259 + mgmt = (struct ieee80211_mgmt *) skb->data;
260 + stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
261 +
262 + if (stype != IEEE80211_STYPE_BEACON)
263 + return;
264 +
265 + baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
266 + if (baselen > skb->len)
267 + return;
268 +
269 + ieee802_11_parse_elems(mgmt->u.probe_resp.variable,
270 + skb->len - baselen, &elems);
271 +
272 + rates = ieee80211_sta_get_rates(local, &elems, band, NULL);
273 +
274 + rcu_read_lock();
275 +
276 + sta = sta_info_get(sdata, sdata->u.wds.remote_addr);
277 +
278 + if (!sta) {
279 + rcu_read_unlock();
280 + sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr,
281 + GFP_KERNEL);
282 + if (!sta)
283 + return;
284 +
285 + new = true;
286 + }
287 +
288 + sta->last_rx = jiffies;
289 + sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
290 +
291 + if (elems.ht_cap_elem)
292 + ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
293 + elems.ht_cap_elem, sta);
294 +
295 + if (elems.wmm_param)
296 + set_sta_flag(sta, WLAN_STA_WME);
297 +
298 + if (new) {
299 + sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
300 + sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
301 + sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
302 + rate_control_rate_init(sta);
303 + sta_info_insert_rcu(sta);
304 + }
305 +
306 + rcu_read_unlock();
307 +}
308 +
309 static void ieee80211_iface_work(struct work_struct *work)
310 {
311 struct ieee80211_sub_if_data *sdata =
312 @@ -1126,6 +1175,9 @@ static void ieee80211_iface_work(struct
313 break;
314 ieee80211_mesh_rx_queued_mgmt(sdata, skb);
315 break;
316 + case NL80211_IFTYPE_WDS:
317 + ieee80211_wds_rx_queued_mgmt(sdata, skb);
318 + break;
319 default:
320 WARN(1, "frame for unexpected interface type");
321 break;
322 --- a/net/mac80211/rx.c
323 +++ b/net/mac80211/rx.c
324 @@ -2365,6 +2365,7 @@ ieee80211_rx_h_action(struct ieee80211_r
325 sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
326 sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
327 sdata->vif.type != NL80211_IFTYPE_AP &&
328 + sdata->vif.type != NL80211_IFTYPE_WDS &&
329 sdata->vif.type != NL80211_IFTYPE_ADHOC)
330 break;
331
332 @@ -2692,14 +2693,15 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_
333
334 if (!ieee80211_vif_is_mesh(&sdata->vif) &&
335 sdata->vif.type != NL80211_IFTYPE_ADHOC &&
336 - sdata->vif.type != NL80211_IFTYPE_STATION)
337 + sdata->vif.type != NL80211_IFTYPE_STATION &&
338 + sdata->vif.type != NL80211_IFTYPE_WDS)
339 return RX_DROP_MONITOR;
340
341 switch (stype) {
342 case cpu_to_le16(IEEE80211_STYPE_AUTH):
343 case cpu_to_le16(IEEE80211_STYPE_BEACON):
344 case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
345 - /* process for all: mesh, mlme, ibss */
346 + /* process for all: mesh, mlme, ibss, wds */
347 break;
348 case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
349 case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
350 @@ -3028,10 +3030,16 @@ static int prepare_for_handlers(struct i
351 }
352 break;
353 case NL80211_IFTYPE_WDS:
354 - if (bssid || !ieee80211_is_data(hdr->frame_control))
355 - return 0;
356 if (!ether_addr_equal(sdata->u.wds.remote_addr, hdr->addr2))
357 return 0;
358 +
359 + if (ieee80211_is_data(hdr->frame_control) ||
360 + ieee80211_is_action(hdr->frame_control)) {
361 + if (compare_ether_addr(sdata->vif.addr, hdr->addr1))
362 + return 0;
363 + } else if (!ieee80211_is_beacon(hdr->frame_control))
364 + return 0;
365 +
366 break;
367 case NL80211_IFTYPE_P2P_DEVICE:
368 if (!ieee80211_is_public_action(hdr, skb->len) &&
369 --- a/net/mac80211/sta_info.h
370 +++ b/net/mac80211/sta_info.h
371 @@ -32,7 +32,6 @@
372 * @WLAN_STA_SHORT_PREAMBLE: Station is capable of receiving short-preamble
373 * frames.
374 * @WLAN_STA_WME: Station is a QoS-STA.
375 - * @WLAN_STA_WDS: Station is one of our WDS peers.
376 * @WLAN_STA_CLEAR_PS_FILT: Clear PS filter in hardware (using the
377 * IEEE80211_TX_CTL_CLEAR_PS_FILT control flag) when the next
378 * frame to this station is transmitted.
379 @@ -66,7 +65,6 @@ enum ieee80211_sta_info_flags {
380 WLAN_STA_AUTHORIZED,
381 WLAN_STA_SHORT_PREAMBLE,
382 WLAN_STA_WME,
383 - WLAN_STA_WDS,
384 WLAN_STA_CLEAR_PS_FILT,
385 WLAN_STA_MFP,
386 WLAN_STA_BLOCK_BA,
387 --- a/net/mac80211/tx.c
388 +++ b/net/mac80211/tx.c
389 @@ -1231,34 +1231,40 @@ static bool ieee80211_tx_frags(struct ie
390 if (local->queue_stop_reasons[q] ||
391 (!txpending && !skb_queue_empty(&local->pending[q]))) {
392 if (unlikely(info->flags &
393 - IEEE80211_TX_INTFL_OFFCHAN_TX_OK &&
394 - local->queue_stop_reasons[q] &
395 - ~BIT(IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL))) {
396 + IEEE80211_TX_INTFL_OFFCHAN_TX_OK)) {
397 + if (local->queue_stop_reasons[q] &
398 + ~BIT(IEEE80211_QUEUE_STOP_REASON_OFFCHANNEL)) {
399 + /*
400 + * Drop off-channel frames if queues
401 + * are stopped for any reason other
402 + * than off-channel operation. Never
403 + * queue them.
404 + */
405 + spin_unlock_irqrestore(
406 + &local->queue_stop_reason_lock,
407 + flags);
408 + ieee80211_purge_tx_queue(&local->hw,
409 + skbs);
410 + return true;
411 + }
412 + } else {
413 +
414 /*
415 - * Drop off-channel frames if queues are stopped
416 - * for any reason other than off-channel
417 - * operation. Never queue them.
418 + * Since queue is stopped, queue up frames for
419 + * later transmission from the tx-pending
420 + * tasklet when the queue is woken again.
421 */
422 - spin_unlock_irqrestore(
423 - &local->queue_stop_reason_lock, flags);
424 - ieee80211_purge_tx_queue(&local->hw, skbs);
425 - return true;
426 + if (txpending)
427 + skb_queue_splice_init(skbs,
428 + &local->pending[q]);
429 + else
430 + skb_queue_splice_tail_init(skbs,
431 + &local->pending[q]);
432 +
433 + spin_unlock_irqrestore(&local->queue_stop_reason_lock,
434 + flags);
435 + return false;
436 }
437 -
438 - /*
439 - * Since queue is stopped, queue up frames for later
440 - * transmission from the tx-pending tasklet when the
441 - * queue is woken again.
442 - */
443 - if (txpending)
444 - skb_queue_splice_init(skbs, &local->pending[q]);
445 - else
446 - skb_queue_splice_tail_init(skbs,
447 - &local->pending[q]);
448 -
449 - spin_unlock_irqrestore(&local->queue_stop_reason_lock,
450 - flags);
451 - return false;
452 }
453 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
454
455 @@ -1848,9 +1854,24 @@ netdev_tx_t ieee80211_subif_start_xmit(s
456 }
457
458 if (!is_multicast_ether_addr(skb->data)) {
459 + struct sta_info *next_hop;
460 + bool mpp_lookup = true;
461 +
462 mpath = mesh_path_lookup(sdata, skb->data);
463 - if (!mpath)
464 + if (mpath) {
465 + mpp_lookup = false;
466 + next_hop = rcu_dereference(mpath->next_hop);
467 + if (!next_hop ||
468 + !(mpath->flags & (MESH_PATH_ACTIVE |
469 + MESH_PATH_RESOLVING)))
470 + mpp_lookup = true;
471 + }
472 +
473 + if (mpp_lookup)
474 mppath = mpp_path_lookup(sdata, skb->data);
475 +
476 + if (mppath && mpath)
477 + mesh_path_del(mpath->sdata, mpath->dst);
478 }
479
480 /*
481 --- a/net/wireless/nl80211.c
482 +++ b/net/wireless/nl80211.c
483 @@ -554,16 +554,9 @@ static int nl80211_msg_put_channel(struc
484 if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
485 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IBSS))
486 goto nla_put_failure;
487 - if (chan->flags & IEEE80211_CHAN_RADAR) {
488 - u32 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
489 - if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
490 - goto nla_put_failure;
491 - if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
492 - chan->dfs_state))
493 - goto nla_put_failure;
494 - if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME, time))
495 - goto nla_put_failure;
496 - }
497 + if ((chan->flags & IEEE80211_CHAN_RADAR) &&
498 + nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
499 + goto nla_put_failure;
500 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
501 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
502 goto nla_put_failure;
503 @@ -900,9 +893,6 @@ static int nl80211_put_iface_combination
504 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
505 c->max_interfaces))
506 goto nla_put_failure;
507 - if (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
508 - c->radar_detect_widths))
509 - goto nla_put_failure;
510
511 nla_nest_end(msg, nl_combi);
512 }
513 @@ -914,48 +904,6 @@ nla_put_failure:
514 return -ENOBUFS;
515 }
516
517 -#ifdef CONFIG_PM
518 -static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
519 - struct sk_buff *msg)
520 -{
521 - const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan.tcp;
522 - struct nlattr *nl_tcp;
523 -
524 - if (!tcp)
525 - return 0;
526 -
527 - nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
528 - if (!nl_tcp)
529 - return -ENOBUFS;
530 -
531 - if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
532 - tcp->data_payload_max))
533 - return -ENOBUFS;
534 -
535 - if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
536 - tcp->data_payload_max))
537 - return -ENOBUFS;
538 -
539 - if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
540 - return -ENOBUFS;
541 -
542 - if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
543 - sizeof(*tcp->tok), tcp->tok))
544 - return -ENOBUFS;
545 -
546 - if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
547 - tcp->data_interval_max))
548 - return -ENOBUFS;
549 -
550 - if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
551 - tcp->wake_payload_max))
552 - return -ENOBUFS;
553 -
554 - nla_nest_end(msg, nl_tcp);
555 - return 0;
556 -}
557 -#endif
558 -
559 static int nl80211_send_wiphy(struct sk_buff *msg, u32 portid, u32 seq, int flags,
560 struct cfg80211_registered_device *dev)
561 {
562 @@ -1330,9 +1278,6 @@ static int nl80211_send_wiphy(struct sk_
563 goto nla_put_failure;
564 }
565
566 - if (nl80211_send_wowlan_tcp_caps(dev, msg))
567 - goto nla_put_failure;
568 -
569 nla_nest_end(msg, nl_wowlan);
570 }
571 #endif
572 --- a/net/mac80211/cfg.c
573 +++ b/net/mac80211/cfg.c
574 @@ -3285,13 +3285,19 @@ static int ieee80211_cfg_get_channel(str
575 struct cfg80211_chan_def *chandef)
576 {
577 struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
578 + struct ieee80211_local *local = wiphy_priv(wiphy);
579 struct ieee80211_chanctx_conf *chanctx_conf;
580 int ret = -ENODATA;
581
582 rcu_read_lock();
583 - chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
584 - if (chanctx_conf) {
585 - *chandef = chanctx_conf->def;
586 + if (local->use_chanctx) {
587 + chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
588 + if (chanctx_conf) {
589 + *chandef = chanctx_conf->def;
590 + ret = 0;
591 + }
592 + } else if (local->open_count == local->monitors) {
593 + *chandef = local->monitor_chandef;
594 ret = 0;
595 }
596 rcu_read_unlock();
597 --- a/drivers/net/wireless/ath/ath9k/hw.c
598 +++ b/drivers/net/wireless/ath/ath9k/hw.c
599 @@ -1463,7 +1463,9 @@ static bool ath9k_hw_chip_reset(struct a
600 reset_type = ATH9K_RESET_POWER_ON;
601 else
602 reset_type = ATH9K_RESET_COLD;
603 - }
604 + } else if (ah->chip_fullsleep || REG_READ(ah, AR_Q_TXE) ||
605 + (REG_READ(ah, AR_CR) & AR_CR_RXE))
606 + reset_type = ATH9K_RESET_COLD;
607
608 if (!ath9k_hw_set_reset_reg(ah, reset_type))
609 return false;
610 @@ -1876,13 +1878,12 @@ int ath9k_hw_reset(struct ath_hw *ah, st
611
612 ENABLE_REGWRITE_BUFFER(ah);
613
614 - REG_WRITE(ah, AR_STA_ID0, get_unaligned_le32(common->macaddr));
615 - REG_WRITE(ah, AR_STA_ID1, get_unaligned_le16(common->macaddr + 4)
616 - | macStaId1
617 + REG_RMW(ah, AR_STA_ID1, macStaId1
618 | AR_STA_ID1_RTS_USE_DEF
619 | (ah->config.
620 ack_6mb ? AR_STA_ID1_ACKCTS_6MB : 0)
621 - | ah->sta_id1_defaults);
622 + | ah->sta_id1_defaults,
623 + ~AR_STA_ID1_SADH_MASK);
624 ath_hw_setbssidmask(common);
625 REG_WRITE(ah, AR_DEF_ANTENNA, saveDefAntenna);
626 ath9k_hw_write_associd(ah);
627 --- a/drivers/net/wireless/rt2x00/rt2x00dev.c
628 +++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
629 @@ -1236,8 +1236,10 @@ static inline void rt2x00lib_set_if_comb
630 */
631 if_limit = &rt2x00dev->if_limits_ap;
632 if_limit->max = rt2x00dev->ops->max_ap_intf;
633 - if_limit->types = BIT(NL80211_IFTYPE_AP) |
634 - BIT(NL80211_IFTYPE_MESH_POINT);
635 + if_limit->types = BIT(NL80211_IFTYPE_AP);
636 +#ifdef CONFIG_MAC80211_MESH
637 + if_limit->types |= BIT(NL80211_IFTYPE_MESH_POINT);
638 +#endif
639
640 /*
641 * Build up AP interface combinations structure.
642 @@ -1309,7 +1311,9 @@ int rt2x00lib_probe_dev(struct rt2x00_de
643 rt2x00dev->hw->wiphy->interface_modes |=
644 BIT(NL80211_IFTYPE_ADHOC) |
645 BIT(NL80211_IFTYPE_AP) |
646 +#ifdef CONFIG_MAC80211_MESH
647 BIT(NL80211_IFTYPE_MESH_POINT) |
648 +#endif
649 BIT(NL80211_IFTYPE_WDS);
650
651 rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
652 --- a/net/mac80211/rc80211_minstrel_ht.c
653 +++ b/net/mac80211/rc80211_minstrel_ht.c
654 @@ -17,8 +17,6 @@
655 #include "rc80211_minstrel_ht.h"
656
657 #define AVG_PKT_SIZE 1200
658 -#define SAMPLE_COLUMNS 10
659 -#define EWMA_LEVEL 75
660
661 /* Number of bits for an average sized packet */
662 #define MCS_NBITS (AVG_PKT_SIZE << 3)
663 @@ -26,11 +24,11 @@
664 /* Number of symbols for a packet with (bps) bits per symbol */
665 #define MCS_NSYMS(bps) ((MCS_NBITS + (bps) - 1) / (bps))
666
667 -/* Transmission time for a packet containing (syms) symbols */
668 +/* Transmission time (nanoseconds) for a packet containing (syms) symbols */
669 #define MCS_SYMBOL_TIME(sgi, syms) \
670 (sgi ? \
671 - ((syms) * 18 + 4) / 5 : /* syms * 3.6 us */ \
672 - (syms) << 2 /* syms * 4 us */ \
673 + ((syms) * 18000 + 4000) / 5 : /* syms * 3.6 us */ \
674 + ((syms) * 1000) << 2 /* syms * 4 us */ \
675 )
676
677 /* Transmit duration for the raw data part of an average sized packet */
678 @@ -64,9 +62,9 @@
679 }
680
681 #define CCK_DURATION(_bitrate, _short, _len) \
682 - (10 /* SIFS */ + \
683 + (1000 * (10 /* SIFS */ + \
684 (_short ? 72 + 24 : 144 + 48 ) + \
685 - (8 * (_len + 4) * 10) / (_bitrate))
686 + (8 * (_len + 4) * 10) / (_bitrate)))
687
688 #define CCK_ACK_DURATION(_bitrate, _short) \
689 (CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) + \
690 @@ -129,15 +127,6 @@ const struct mcs_group minstrel_mcs_grou
691 static u8 sample_table[SAMPLE_COLUMNS][MCS_GROUP_RATES];
692
693 /*
694 - * Perform EWMA (Exponentially Weighted Moving Average) calculation
695 - */
696 -static int
697 -minstrel_ewma(int old, int new, int weight)
698 -{
699 - return (new * (100 - weight) + old * weight) / 100;
700 -}
701 -
702 -/*
703 * Look up an MCS group index based on mac80211 rate information
704 */
705 static int
706 @@ -211,20 +200,32 @@ static void
707 minstrel_ht_calc_tp(struct minstrel_ht_sta *mi, int group, int rate)
708 {
709 struct minstrel_rate_stats *mr;
710 - unsigned int usecs = 0;
711 + unsigned int nsecs = 0;
712 + unsigned int tp;
713 + unsigned int prob;
714
715 mr = &mi->groups[group].rates[rate];
716 + prob = mr->probability;
717
718 - if (mr->probability < MINSTREL_FRAC(1, 10)) {
719 + if (prob < MINSTREL_FRAC(1, 10)) {
720 mr->cur_tp = 0;
721 return;
722 }
723
724 + /*
725 + * For the throughput calculation, limit the probability value to 90% to
726 + * account for collision related packet error rate fluctuation
727 + */
728 + if (prob > MINSTREL_FRAC(9, 10))
729 + prob = MINSTREL_FRAC(9, 10);
730 +
731 if (group != MINSTREL_CCK_GROUP)
732 - usecs = mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
733 + nsecs = 1000 * mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
734 +
735 + nsecs += minstrel_mcs_groups[group].duration[rate];
736 + tp = 1000000 * ((mr->probability * 1000) / nsecs);
737
738 - usecs += minstrel_mcs_groups[group].duration[rate];
739 - mr->cur_tp = MINSTREL_TRUNC((1000000 / usecs) * mr->probability);
740 + mr->cur_tp = MINSTREL_TRUNC(tp);
741 }
742
743 /*
744 @@ -308,8 +309,8 @@ minstrel_ht_update_stats(struct minstrel
745 }
746 }
747
748 - /* try to sample up to half of the available rates during each interval */
749 - mi->sample_count *= 4;
750 + /* try to sample all available rates during each interval */
751 + mi->sample_count *= 8;
752
753 cur_prob = 0;
754 cur_prob_tp = 0;
755 @@ -320,20 +321,13 @@ minstrel_ht_update_stats(struct minstrel
756 if (!mg->supported)
757 continue;
758
759 - mr = minstrel_get_ratestats(mi, mg->max_prob_rate);
760 - if (cur_prob_tp < mr->cur_tp &&
761 - minstrel_mcs_groups[group].streams == 1) {
762 - mi->max_prob_rate = mg->max_prob_rate;
763 - cur_prob = mr->cur_prob;
764 - cur_prob_tp = mr->cur_tp;
765 - }
766 -
767 mr = minstrel_get_ratestats(mi, mg->max_tp_rate);
768 if (cur_tp < mr->cur_tp) {
769 mi->max_tp_rate2 = mi->max_tp_rate;
770 cur_tp2 = cur_tp;
771 mi->max_tp_rate = mg->max_tp_rate;
772 cur_tp = mr->cur_tp;
773 + mi->max_prob_streams = minstrel_mcs_groups[group].streams - 1;
774 }
775
776 mr = minstrel_get_ratestats(mi, mg->max_tp_rate2);
777 @@ -343,6 +337,23 @@ minstrel_ht_update_stats(struct minstrel
778 }
779 }
780
781 + if (mi->max_prob_streams < 1)
782 + mi->max_prob_streams = 1;
783 +
784 + for (group = 0; group < ARRAY_SIZE(minstrel_mcs_groups); group++) {
785 + mg = &mi->groups[group];
786 + if (!mg->supported)
787 + continue;
788 + mr = minstrel_get_ratestats(mi, mg->max_prob_rate);
789 + if (cur_prob_tp < mr->cur_tp &&
790 + minstrel_mcs_groups[group].streams <= mi->max_prob_streams) {
791 + mi->max_prob_rate = mg->max_prob_rate;
792 + cur_prob = mr->cur_prob;
793 + cur_prob_tp = mr->cur_tp;
794 + }
795 + }
796 +
797 +
798 mi->stats_update = jiffies;
799 }
800
801 @@ -467,7 +478,7 @@ minstrel_ht_tx_status(void *priv, struct
802
803 if (!mi->sample_wait && !mi->sample_tries && mi->sample_count > 0) {
804 mi->sample_wait = 16 + 2 * MINSTREL_TRUNC(mi->avg_ampdu_len);
805 - mi->sample_tries = 2;
806 + mi->sample_tries = 1;
807 mi->sample_count--;
808 }
809
810 @@ -536,7 +547,7 @@ minstrel_calc_retransmit(struct minstrel
811 mr->retry_updated = true;
812
813 group = &minstrel_mcs_groups[index / MCS_GROUP_RATES];
814 - tx_time_data = group->duration[index % MCS_GROUP_RATES] * ampdu_len;
815 + tx_time_data = group->duration[index % MCS_GROUP_RATES] * ampdu_len / 1000;
816
817 /* Contention time for first 2 tries */
818 ctime = (t_slot * cw) >> 1;
819 @@ -616,6 +627,7 @@ minstrel_get_sample_rate(struct minstrel
820 {
821 struct minstrel_rate_stats *mr;
822 struct minstrel_mcs_group_data *mg;
823 + unsigned int sample_dur, sample_group;
824 int sample_idx = 0;
825
826 if (mi->sample_wait > 0) {
827 @@ -626,39 +638,46 @@ minstrel_get_sample_rate(struct minstrel
828 if (!mi->sample_tries)
829 return -1;
830
831 - mi->sample_tries--;
832 mg = &mi->groups[mi->sample_group];
833 sample_idx = sample_table[mg->column][mg->index];
834 mr = &mg->rates[sample_idx];
835 - sample_idx += mi->sample_group * MCS_GROUP_RATES;
836 + sample_group = mi->sample_group;
837 + sample_idx += sample_group * MCS_GROUP_RATES;
838 minstrel_next_sample_idx(mi);
839
840 /*
841 * Sampling might add some overhead (RTS, no aggregation)
842 * to the frame. Hence, don't use sampling for the currently
843 - * used max TP rate.
844 + * used rates.
845 */
846 - if (sample_idx == mi->max_tp_rate)
847 + if (sample_idx == mi->max_tp_rate ||
848 + sample_idx == mi->max_tp_rate2 ||
849 + sample_idx == mi->max_prob_rate)
850 return -1;
851 +
852 /*
853 - * When not using MRR, do not sample if the probability is already
854 - * higher than 95% to avoid wasting airtime
855 + * Do not sample if the probability is already higher than 95%
856 + * to avoid wasting airtime.
857 */
858 - if (!mp->has_mrr && (mr->probability > MINSTREL_FRAC(95, 100)))
859 + if (mr->probability > MINSTREL_FRAC(95, 100))
860 return -1;
861
862 /*
863 * Make sure that lower rates get sampled only occasionally,
864 * if the link is working perfectly.
865 */
866 - if (minstrel_get_duration(sample_idx) >
867 - minstrel_get_duration(mi->max_tp_rate)) {
868 + sample_dur = minstrel_get_duration(sample_idx);
869 + if (sample_dur >= minstrel_get_duration(mi->max_tp_rate2) &&
870 + (mi->max_prob_streams <
871 + minstrel_mcs_groups[sample_group].streams ||
872 + sample_dur >= minstrel_get_duration(mi->max_prob_rate))) {
873 if (mr->sample_skipped < 20)
874 return -1;
875
876 if (mi->sample_slow++ > 2)
877 return -1;
878 }
879 + mi->sample_tries--;
880
881 return sample_idx;
882 }
883 --- a/net/mac80211/rc80211_minstrel_ht.h
884 +++ b/net/mac80211/rc80211_minstrel_ht.h
885 @@ -16,11 +16,6 @@
886 #define MINSTREL_MAX_STREAMS 3
887 #define MINSTREL_STREAM_GROUPS 4
888
889 -/* scaled fraction values */
890 -#define MINSTREL_SCALE 16
891 -#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div)
892 -#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE)
893 -
894 #define MCS_GROUP_RATES 8
895
896 struct mcs_group {
897 @@ -85,6 +80,7 @@ struct minstrel_ht_sta {
898
899 /* best probability rate */
900 unsigned int max_prob_rate;
901 + unsigned int max_prob_streams;
902
903 /* time of last status update */
904 unsigned long stats_update;
905 --- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c
906 +++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
907 @@ -1023,6 +1023,7 @@ static bool ar9003_hw_init_cal(struct at
908 AR_PHY_AGC_CONTROL_FLTR_CAL |
909 AR_PHY_AGC_CONTROL_PKDET_CAL;
910
911 + /* Use chip chainmask only for calibration */
912 ar9003_hw_set_chain_masks(ah, ah->caps.rx_chainmask, ah->caps.tx_chainmask);
913
914 if (rtt) {
915 @@ -1150,6 +1151,9 @@ skip_tx_iqcal:
916 ar9003_hw_rtt_disable(ah);
917 }
918
919 + /* Revert chainmask to runtime parameters */
920 + ar9003_hw_set_chain_masks(ah, ah->rxchainmask, ah->txchainmask);
921 +
922 /* Initialize list pointers */
923 ah->cal_list = ah->cal_list_last = ah->cal_list_curr = NULL;
924
925 --- a/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
926 +++ b/drivers/net/wireless/ath/ath9k/ar9003_eeprom.c
927 @@ -3606,6 +3606,12 @@ static void ar9003_hw_ant_ctrl_apply(str
928 value = ar9003_hw_ant_ctrl_common_2_get(ah, is2ghz);
929 REG_RMW_FIELD(ah, AR_PHY_SWITCH_COM_2, AR_SWITCH_TABLE_COM2_ALL, value);
930
931 + if ((AR_SREV_9462(ah)) && (ah->rxchainmask == 0x2)) {
932 + value = ar9003_hw_ant_ctrl_chain_get(ah, 1, is2ghz);
933 + REG_RMW_FIELD(ah, switch_chain_reg[0],
934 + AR_SWITCH_TABLE_ALL, value);
935 + }
936 +
937 for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) {
938 if ((ah->rxchainmask & BIT(chain)) ||
939 (ah->txchainmask & BIT(chain))) {
940 @@ -3772,6 +3778,17 @@ static void ar9003_hw_atten_apply(struct
941 AR_PHY_EXT_ATTEN_CTL_2,
942 };
943
944 + if ((AR_SREV_9462(ah)) && (ah->rxchainmask == 0x2)) {
945 + value = ar9003_hw_atten_chain_get(ah, 1, chan);
946 + REG_RMW_FIELD(ah, ext_atten_reg[0],
947 + AR_PHY_EXT_ATTEN_CTL_XATTEN1_DB, value);
948 +
949 + value = ar9003_hw_atten_chain_get_margin(ah, 1, chan);
950 + REG_RMW_FIELD(ah, ext_atten_reg[0],
951 + AR_PHY_EXT_ATTEN_CTL_XATTEN1_MARGIN,
952 + value);
953 + }
954 +
955 /* Test value. if 0 then attenuation is unused. Don't load anything. */
956 for (i = 0; i < 3; i++) {
957 if (ah->txchainmask & BIT(i)) {
958 --- a/drivers/net/wireless/ath/ath9k/link.c
959 +++ b/drivers/net/wireless/ath/ath9k/link.c
960 @@ -28,21 +28,21 @@ void ath_tx_complete_poll_work(struct wo
961 int i;
962 bool needreset = false;
963
964 - for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++)
965 - if (ATH_TXQ_SETUP(sc, i)) {
966 - txq = &sc->tx.txq[i];
967 - ath_txq_lock(sc, txq);
968 - if (txq->axq_depth) {
969 - if (txq->axq_tx_inprogress) {
970 - needreset = true;
971 - ath_txq_unlock(sc, txq);
972 - break;
973 - } else {
974 - txq->axq_tx_inprogress = true;
975 - }
976 + for (i = 0; i < IEEE80211_NUM_ACS; i++) {
977 + txq = sc->tx.txq_map[i];
978 +
979 + ath_txq_lock(sc, txq);
980 + if (txq->axq_depth) {
981 + if (txq->axq_tx_inprogress) {
982 + needreset = true;
983 + ath_txq_unlock(sc, txq);
984 + break;
985 + } else {
986 + txq->axq_tx_inprogress = true;
987 }
988 - ath_txq_unlock_complete(sc, txq);
989 }
990 + ath_txq_unlock_complete(sc, txq);
991 + }
992
993 if (needreset) {
994 ath_dbg(ath9k_hw_common(sc->sc_ah), RESET,
995 --- a/net/mac80211/sta_info.c
996 +++ b/net/mac80211/sta_info.c
997 @@ -766,6 +766,7 @@ int __must_check __sta_info_destroy(stru
998 struct ieee80211_local *local;
999 struct ieee80211_sub_if_data *sdata;
1000 int ret, i;
1001 + bool have_key = false;
1002
1003 might_sleep();
1004
1005 @@ -793,12 +794,19 @@ int __must_check __sta_info_destroy(stru
1006 list_del_rcu(&sta->list);
1007
1008 mutex_lock(&local->key_mtx);
1009 - for (i = 0; i < NUM_DEFAULT_KEYS; i++)
1010 + for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1011 __ieee80211_key_free(key_mtx_dereference(local, sta->gtk[i]));
1012 - if (sta->ptk)
1013 + have_key = true;
1014 + }
1015 + if (sta->ptk) {
1016 __ieee80211_key_free(key_mtx_dereference(local, sta->ptk));
1017 + have_key = true;
1018 + }
1019 mutex_unlock(&local->key_mtx);
1020
1021 + if (!have_key)
1022 + synchronize_net();
1023 +
1024 sta->dead = true;
1025
1026 local->num_sta--;
1027 --- a/net/mac80211/chan.c
1028 +++ b/net/mac80211/chan.c
1029 @@ -63,6 +63,7 @@ ieee80211_new_chanctx(struct ieee80211_l
1030 enum ieee80211_chanctx_mode mode)
1031 {
1032 struct ieee80211_chanctx *ctx;
1033 + u32 changed;
1034 int err;
1035
1036 lockdep_assert_held(&local->chanctx_mtx);
1037 @@ -76,6 +77,13 @@ ieee80211_new_chanctx(struct ieee80211_l
1038 ctx->conf.rx_chains_dynamic = 1;
1039 ctx->mode = mode;
1040
1041 + /* acquire mutex to prevent idle from changing */
1042 + mutex_lock(&local->mtx);
1043 + /* turn idle off *before* setting channel -- some drivers need that */
1044 + changed = ieee80211_idle_off(local);
1045 + if (changed)
1046 + ieee80211_hw_config(local, changed);
1047 +
1048 if (!local->use_chanctx) {
1049 local->_oper_channel_type =
1050 cfg80211_get_chandef_type(chandef);
1051 @@ -85,14 +93,17 @@ ieee80211_new_chanctx(struct ieee80211_l
1052 err = drv_add_chanctx(local, ctx);
1053 if (err) {
1054 kfree(ctx);
1055 - return ERR_PTR(err);
1056 + ctx = ERR_PTR(err);
1057 +
1058 + ieee80211_recalc_idle(local);
1059 + goto out;
1060 }
1061 }
1062
1063 + /* and keep the mutex held until the new chanctx is on the list */
1064 list_add_rcu(&ctx->list, &local->chanctx_list);
1065
1066 - mutex_lock(&local->mtx);
1067 - ieee80211_recalc_idle(local);
1068 + out:
1069 mutex_unlock(&local->mtx);
1070
1071 return ctx;
1072 --- a/net/mac80211/ieee80211_i.h
1073 +++ b/net/mac80211/ieee80211_i.h
1074 @@ -1366,6 +1366,7 @@ int ieee80211_if_change_type(struct ieee
1075 enum nl80211_iftype type);
1076 void ieee80211_if_remove(struct ieee80211_sub_if_data *sdata);
1077 void ieee80211_remove_interfaces(struct ieee80211_local *local);
1078 +u32 ieee80211_idle_off(struct ieee80211_local *local);
1079 void ieee80211_recalc_idle(struct ieee80211_local *local);
1080 void ieee80211_adjust_monitor_flags(struct ieee80211_sub_if_data *sdata,
1081 const int offset);
1082 --- a/drivers/net/wireless/ath/ath9k/htc_drv_init.c
1083 +++ b/drivers/net/wireless/ath/ath9k/htc_drv_init.c
1084 @@ -799,7 +799,7 @@ static int ath9k_init_firmware_version(s
1085 * required version.
1086 */
1087 if (priv->fw_version_major != MAJOR_VERSION_REQ ||
1088 - priv->fw_version_minor != MINOR_VERSION_REQ) {
1089 + priv->fw_version_minor < MINOR_VERSION_REQ) {
1090 dev_err(priv->dev, "ath9k_htc: Please upgrade to FW version %d.%d\n",
1091 MAJOR_VERSION_REQ, MINOR_VERSION_REQ);
1092 return -EINVAL;
1093 --- a/drivers/net/wireless/ath/ath9k/xmit.c
1094 +++ b/drivers/net/wireless/ath/ath9k/xmit.c
1095 @@ -516,8 +516,7 @@ static void ath_tx_complete_aggr(struct
1096 * not a holding desc.
1097 */
1098 INIT_LIST_HEAD(&bf_head);
1099 - if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) ||
1100 - bf_next != NULL || !bf_last->bf_stale)
1101 + if (bf_next != NULL || !bf_last->bf_stale)
1102 list_move_tail(&bf->list, &bf_head);
1103
1104 if (!txpending || (tid->state & AGGR_CLEANUP)) {
1105 @@ -537,8 +536,7 @@ static void ath_tx_complete_aggr(struct
1106 !txfail);
1107 } else {
1108 /* retry the un-acked ones */
1109 - if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
1110 - bf->bf_next == NULL && bf_last->bf_stale) {
1111 + if (bf->bf_next == NULL && bf_last->bf_stale) {
1112 struct ath_buf *tbf;
1113
1114 tbf = ath_clone_txbuf(sc, bf_last);
1115 @@ -2264,6 +2262,7 @@ void ath_tx_edma_tasklet(struct ath_soft
1116 struct ath_txq *txq;
1117 struct ath_buf *bf, *lastbf;
1118 struct list_head bf_head;
1119 + struct list_head *fifo_list;
1120 int status;
1121
1122 for (;;) {
1123 @@ -2291,20 +2290,24 @@ void ath_tx_edma_tasklet(struct ath_soft
1124
1125 TX_STAT_INC(txq->axq_qnum, txprocdesc);
1126
1127 - if (list_empty(&txq->txq_fifo[txq->txq_tailidx])) {
1128 + fifo_list = &txq->txq_fifo[txq->txq_tailidx];
1129 + if (list_empty(fifo_list)) {
1130 ath_txq_unlock(sc, txq);
1131 return;
1132 }
1133
1134 - bf = list_first_entry(&txq->txq_fifo[txq->txq_tailidx],
1135 - struct ath_buf, list);
1136 + bf = list_first_entry(fifo_list, struct ath_buf, list);
1137 + if (bf->bf_stale) {
1138 + list_del(&bf->list);
1139 + ath_tx_return_buffer(sc, bf);
1140 + bf = list_first_entry(fifo_list, struct ath_buf, list);
1141 + }
1142 +
1143 lastbf = bf->bf_lastbf;
1144
1145 INIT_LIST_HEAD(&bf_head);
1146 - list_cut_position(&bf_head, &txq->txq_fifo[txq->txq_tailidx],
1147 - &lastbf->list);
1148 -
1149 - if (list_empty(&txq->txq_fifo[txq->txq_tailidx])) {
1150 + if (list_is_last(&lastbf->list, fifo_list)) {
1151 + list_splice_tail_init(fifo_list, &bf_head);
1152 INCR(txq->txq_tailidx, ATH_TXFIFO_DEPTH);
1153
1154 if (!list_empty(&txq->axq_q)) {
1155 @@ -2315,6 +2318,11 @@ void ath_tx_edma_tasklet(struct ath_soft
1156 list_splice_tail_init(&txq->axq_q, &bf_q);
1157 ath_tx_txqaddbuf(sc, txq, &bf_q, true);
1158 }
1159 + } else {
1160 + lastbf->bf_stale = true;
1161 + if (bf != lastbf)
1162 + list_cut_position(&bf_head, fifo_list,
1163 + lastbf->list.prev);
1164 }
1165
1166 ath_tx_process_buffer(sc, txq, &ts, bf, &bf_head);
1167 --- a/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h
1168 +++ b/drivers/net/wireless/ath/ath9k/ar9580_1p0_initvals.h
1169 @@ -519,7 +519,7 @@ static const u32 ar9580_1p0_mac_core[][2
1170 {0x00008258, 0x00000000},
1171 {0x0000825c, 0x40000000},
1172 {0x00008260, 0x00080922},
1173 - {0x00008264, 0x9bc00010},
1174 + {0x00008264, 0x9d400010},
1175 {0x00008268, 0xffffffff},
1176 {0x0000826c, 0x0000ffff},
1177 {0x00008270, 0x00000000},
1178 --- a/net/mac80211/mlme.c
1179 +++ b/net/mac80211/mlme.c
1180 @@ -3955,8 +3955,16 @@ int ieee80211_mgd_auth(struct ieee80211_
1181 /* prep auth_data so we don't go into idle on disassoc */
1182 ifmgd->auth_data = auth_data;
1183
1184 - if (ifmgd->associated)
1185 - ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
1186 + if (ifmgd->associated) {
1187 + u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
1188 +
1189 + ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
1190 + WLAN_REASON_UNSPECIFIED,
1191 + false, frame_buf);
1192 +
1193 + __cfg80211_send_deauth(sdata->dev, frame_buf,
1194 + sizeof(frame_buf));
1195 + }
1196
1197 sdata_info(sdata, "authenticate with %pM\n", req->bss->bssid);
1198
1199 @@ -4016,8 +4024,16 @@ int ieee80211_mgd_assoc(struct ieee80211
1200
1201 mutex_lock(&ifmgd->mtx);
1202
1203 - if (ifmgd->associated)
1204 - ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
1205 + if (ifmgd->associated) {
1206 + u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
1207 +
1208 + ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
1209 + WLAN_REASON_UNSPECIFIED,
1210 + false, frame_buf);
1211 +
1212 + __cfg80211_send_deauth(sdata->dev, frame_buf,
1213 + sizeof(frame_buf));
1214 + }
1215
1216 if (ifmgd->auth_data && !ifmgd->auth_data->done) {
1217 err = -EBUSY;
1218 --- a/net/mac80211/rc80211_minstrel.c
1219 +++ b/net/mac80211/rc80211_minstrel.c
1220 @@ -55,7 +55,6 @@
1221 #include "rate.h"
1222 #include "rc80211_minstrel.h"
1223
1224 -#define SAMPLE_COLUMNS 10
1225 #define SAMPLE_TBL(_mi, _idx, _col) \
1226 _mi->sample_table[(_idx * SAMPLE_COLUMNS) + _col]
1227
1228 @@ -70,16 +69,31 @@ rix_to_ndx(struct minstrel_sta_info *mi,
1229 return i;
1230 }
1231
1232 +/* find & sort topmost throughput rates */
1233 +static inline void
1234 +minstrel_sort_best_tp_rates(struct minstrel_sta_info *mi, int i, u8 *tp_list)
1235 +{
1236 + int j = MAX_THR_RATES;
1237 +
1238 + while (j > 0 && mi->r[i].cur_tp > mi->r[tp_list[j - 1]].cur_tp)
1239 + j--;
1240 + if (j < MAX_THR_RATES - 1)
1241 + memmove(&tp_list[j + 1], &tp_list[j], MAX_THR_RATES - (j + 1));
1242 + if (j < MAX_THR_RATES)
1243 + tp_list[j] = i;
1244 +}
1245 +
1246 static void
1247 minstrel_update_stats(struct minstrel_priv *mp, struct minstrel_sta_info *mi)
1248 {
1249 - u32 max_tp = 0, index_max_tp = 0, index_max_tp2 = 0;
1250 - u32 max_prob = 0, index_max_prob = 0;
1251 + u8 tmp_tp_rate[MAX_THR_RATES];
1252 + u8 tmp_prob_rate = 0;
1253 u32 usecs;
1254 - u32 p;
1255 int i;
1256
1257 - mi->stats_update = jiffies;
1258 + for (i=0; i < MAX_THR_RATES; i++)
1259 + tmp_tp_rate[i] = 0;
1260 +
1261 for (i = 0; i < mi->n_rates; i++) {
1262 struct minstrel_rate *mr = &mi->r[i];
1263
1264 @@ -87,27 +101,32 @@ minstrel_update_stats(struct minstrel_pr
1265 if (!usecs)
1266 usecs = 1000000;
1267
1268 - /* To avoid rounding issues, probabilities scale from 0 (0%)
1269 - * to 18000 (100%) */
1270 - if (mr->attempts) {
1271 - p = (mr->success * 18000) / mr->attempts;
1272 + if (unlikely(mr->attempts > 0)) {
1273 + mr->sample_skipped = 0;
1274 + mr->cur_prob = MINSTREL_FRAC(mr->success, mr->attempts);
1275 mr->succ_hist += mr->success;
1276 mr->att_hist += mr->attempts;
1277 - mr->cur_prob = p;
1278 - p = ((p * (100 - mp->ewma_level)) + (mr->probability *
1279 - mp->ewma_level)) / 100;
1280 - mr->probability = p;
1281 - mr->cur_tp = p * (1000000 / usecs);
1282 - }
1283 + mr->probability = minstrel_ewma(mr->probability,
1284 + mr->cur_prob,
1285 + EWMA_LEVEL);
1286 + } else
1287 + mr->sample_skipped++;
1288
1289 mr->last_success = mr->success;
1290 mr->last_attempts = mr->attempts;
1291 mr->success = 0;
1292 mr->attempts = 0;
1293
1294 + /* Update throughput per rate, reset thr. below 10% success */
1295 + if (mr->probability < MINSTREL_FRAC(10, 100))
1296 + mr->cur_tp = 0;
1297 + else
1298 + mr->cur_tp = mr->probability * (1000000 / usecs);
1299 +
1300 /* Sample less often below the 10% chance of success.
1301 * Sample less often above the 95% chance of success. */
1302 - if ((mr->probability > 17100) || (mr->probability < 1800)) {
1303 + if (mr->probability > MINSTREL_FRAC(95, 100) ||
1304 + mr->probability < MINSTREL_FRAC(10, 100)) {
1305 mr->adjusted_retry_count = mr->retry_count >> 1;
1306 if (mr->adjusted_retry_count > 2)
1307 mr->adjusted_retry_count = 2;
1308 @@ -118,35 +137,30 @@ minstrel_update_stats(struct minstrel_pr
1309 }
1310 if (!mr->adjusted_retry_count)
1311 mr->adjusted_retry_count = 2;
1312 - }
1313
1314 - for (i = 0; i < mi->n_rates; i++) {
1315 - struct minstrel_rate *mr = &mi->r[i];
1316 - if (max_tp < mr->cur_tp) {
1317 - index_max_tp = i;
1318 - max_tp = mr->cur_tp;
1319 - }
1320 - if (max_prob < mr->probability) {
1321 - index_max_prob = i;
1322 - max_prob = mr->probability;
1323 + minstrel_sort_best_tp_rates(mi, i, tmp_tp_rate);
1324 +
1325 + /* To determine the most robust rate (max_prob_rate) used at
1326 + * 3rd mmr stage we distinct between two cases:
1327 + * (1) if any success probabilitiy >= 95%, out of those rates
1328 + * choose the maximum throughput rate as max_prob_rate
1329 + * (2) if all success probabilities < 95%, the rate with
1330 + * highest success probability is choosen as max_prob_rate */
1331 + if (mr->probability >= MINSTREL_FRAC(95,100)) {
1332 + if (mr->cur_tp >= mi->r[tmp_prob_rate].cur_tp)
1333 + tmp_prob_rate = i;
1334 + } else {
1335 + if (mr->probability >= mi->r[tmp_prob_rate].probability)
1336 + tmp_prob_rate = i;
1337 }
1338 }
1339
1340 - max_tp = 0;
1341 - for (i = 0; i < mi->n_rates; i++) {
1342 - struct minstrel_rate *mr = &mi->r[i];
1343 -
1344 - if (i == index_max_tp)
1345 - continue;
1346 + /* Assign the new rate set */
1347 + memcpy(mi->max_tp_rate, tmp_tp_rate, sizeof(mi->max_tp_rate));
1348 + mi->max_prob_rate = tmp_prob_rate;
1349
1350 - if (max_tp < mr->cur_tp) {
1351 - index_max_tp2 = i;
1352 - max_tp = mr->cur_tp;
1353 - }
1354 - }
1355 - mi->max_tp_rate = index_max_tp;
1356 - mi->max_tp_rate2 = index_max_tp2;
1357 - mi->max_prob_rate = index_max_prob;
1358 + /* Reset update timer */
1359 + mi->stats_update = jiffies;
1360 }
1361
1362 static void
1363 @@ -207,10 +221,10 @@ static int
1364 minstrel_get_next_sample(struct minstrel_sta_info *mi)
1365 {
1366 unsigned int sample_ndx;
1367 - sample_ndx = SAMPLE_TBL(mi, mi->sample_idx, mi->sample_column);
1368 - mi->sample_idx++;
1369 - if ((int) mi->sample_idx > (mi->n_rates - 2)) {
1370 - mi->sample_idx = 0;
1371 + sample_ndx = SAMPLE_TBL(mi, mi->sample_row, mi->sample_column);
1372 + mi->sample_row++;
1373 + if ((int) mi->sample_row >= mi->n_rates) {
1374 + mi->sample_row = 0;
1375 mi->sample_column++;
1376 if (mi->sample_column >= SAMPLE_COLUMNS)
1377 mi->sample_column = 0;
1378 @@ -228,31 +242,37 @@ minstrel_get_rate(void *priv, struct iee
1379 struct minstrel_priv *mp = priv;
1380 struct ieee80211_tx_rate *ar = info->control.rates;
1381 unsigned int ndx, sample_ndx = 0;
1382 - bool mrr;
1383 - bool sample_slower = false;
1384 - bool sample = false;
1385 + bool mrr_capable;
1386 + bool indirect_rate_sampling = false;
1387 + bool rate_sampling = false;
1388 int i, delta;
1389 int mrr_ndx[3];
1390 - int sample_rate;
1391 + int sampling_ratio;
1392
1393 + /* management/no-ack frames do not use rate control */
1394 if (rate_control_send_low(sta, priv_sta, txrc))
1395 return;
1396
1397 - mrr = mp->has_mrr && !txrc->rts && !txrc->bss_conf->use_cts_prot;
1398 -
1399 - ndx = mi->max_tp_rate;
1400 -
1401 - if (mrr)
1402 - sample_rate = mp->lookaround_rate_mrr;
1403 + /* check multi-rate-retry capabilities & adjust lookaround_rate */
1404 + mrr_capable = mp->has_mrr &&
1405 + !txrc->rts &&
1406 + !txrc->bss_conf->use_cts_prot;
1407 + if (mrr_capable)
1408 + sampling_ratio = mp->lookaround_rate_mrr;
1409 else
1410 - sample_rate = mp->lookaround_rate;
1411 + sampling_ratio = mp->lookaround_rate;
1412 +
1413 + /* init rateindex [ndx] with max throughput rate */
1414 + ndx = mi->max_tp_rate[0];
1415
1416 + /* increase sum packet counter */
1417 mi->packet_count++;
1418 - delta = (mi->packet_count * sample_rate / 100) -
1419 +
1420 + delta = (mi->packet_count * sampling_ratio / 100) -
1421 (mi->sample_count + mi->sample_deferred / 2);
1422
1423 /* delta > 0: sampling required */
1424 - if ((delta > 0) && (mrr || !mi->prev_sample)) {
1425 + if ((delta > 0) && (mrr_capable || !mi->prev_sample)) {
1426 struct minstrel_rate *msr;
1427 if (mi->packet_count >= 10000) {
1428 mi->sample_deferred = 0;
1429 @@ -271,21 +291,28 @@ minstrel_get_rate(void *priv, struct iee
1430 mi->sample_count += (delta - mi->n_rates * 2);
1431 }
1432
1433 + /* get next random rate sample */
1434 sample_ndx = minstrel_get_next_sample(mi);
1435 msr = &mi->r[sample_ndx];
1436 - sample = true;
1437 - sample_slower = mrr && (msr->perfect_tx_time >
1438 - mi->r[ndx].perfect_tx_time);
1439 + rate_sampling = true;
1440
1441 - if (!sample_slower) {
1442 + /* Decide if direct ( 1st mrr stage) or indirect (2nd mrr stage)
1443 + * rate sampling method should be used.
1444 + * Respect such rates that are not sampled for 20 interations.
1445 + */
1446 + if (mrr_capable &&
1447 + msr->perfect_tx_time > mi->r[ndx].perfect_tx_time &&
1448 + msr->sample_skipped < 20)
1449 + indirect_rate_sampling = true;
1450 +
1451 + if (!indirect_rate_sampling) {
1452 if (msr->sample_limit != 0) {
1453 ndx = sample_ndx;
1454 mi->sample_count++;
1455 if (msr->sample_limit > 0)
1456 msr->sample_limit--;
1457 - } else {
1458 - sample = false;
1459 - }
1460 + } else
1461 + rate_sampling = false;
1462 } else {
1463 /* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark
1464 * packets that have the sampling rate deferred to the
1465 @@ -297,34 +324,39 @@ minstrel_get_rate(void *priv, struct iee
1466 mi->sample_deferred++;
1467 }
1468 }
1469 - mi->prev_sample = sample;
1470 + mi->prev_sample = rate_sampling;
1471
1472 /* If we're not using MRR and the sampling rate already
1473 * has a probability of >95%, we shouldn't be attempting
1474 * to use it, as this only wastes precious airtime */
1475 - if (!mrr && sample && (mi->r[ndx].probability > 17100))
1476 - ndx = mi->max_tp_rate;
1477 + if (!mrr_capable && rate_sampling &&
1478 + (mi->r[ndx].probability > MINSTREL_FRAC(95, 100)))
1479 + ndx = mi->max_tp_rate[0];
1480
1481 + /* mrr setup for 1st stage */
1482 ar[0].idx = mi->r[ndx].rix;
1483 ar[0].count = minstrel_get_retry_count(&mi->r[ndx], info);
1484
1485 - if (!mrr) {
1486 - if (!sample)
1487 + /* non mrr setup for 2nd stage */
1488 + if (!mrr_capable) {
1489 + if (!rate_sampling)
1490 ar[0].count = mp->max_retry;
1491 ar[1].idx = mi->lowest_rix;
1492 ar[1].count = mp->max_retry;
1493 return;
1494 }
1495
1496 - /* MRR setup */
1497 - if (sample) {
1498 - if (sample_slower)
1499 + /* mrr setup for 2nd stage */
1500 + if (rate_sampling) {
1501 + if (indirect_rate_sampling)
1502 mrr_ndx[0] = sample_ndx;
1503 else
1504 - mrr_ndx[0] = mi->max_tp_rate;
1505 + mrr_ndx[0] = mi->max_tp_rate[0];
1506 } else {
1507 - mrr_ndx[0] = mi->max_tp_rate2;
1508 + mrr_ndx[0] = mi->max_tp_rate[1];
1509 }
1510 +
1511 + /* mrr setup for 3rd & 4th stage */
1512 mrr_ndx[1] = mi->max_prob_rate;
1513 mrr_ndx[2] = 0;
1514 for (i = 1; i < 4; i++) {
1515 @@ -351,26 +383,21 @@ static void
1516 init_sample_table(struct minstrel_sta_info *mi)
1517 {
1518 unsigned int i, col, new_idx;
1519 - unsigned int n_srates = mi->n_rates - 1;
1520 u8 rnd[8];
1521
1522 mi->sample_column = 0;
1523 - mi->sample_idx = 0;
1524 - memset(mi->sample_table, 0, SAMPLE_COLUMNS * mi->n_rates);
1525 + mi->sample_row = 0;
1526 + memset(mi->sample_table, 0xff, SAMPLE_COLUMNS * mi->n_rates);
1527
1528 for (col = 0; col < SAMPLE_COLUMNS; col++) {
1529 - for (i = 0; i < n_srates; i++) {
1530 + for (i = 0; i < mi->n_rates; i++) {
1531 get_random_bytes(rnd, sizeof(rnd));
1532 - new_idx = (i + rnd[i & 7]) % n_srates;
1533 + new_idx = (i + rnd[i & 7]) % mi->n_rates;
1534
1535 - while (SAMPLE_TBL(mi, new_idx, col) != 0)
1536 - new_idx = (new_idx + 1) % n_srates;
1537 + while (SAMPLE_TBL(mi, new_idx, col) != 0xff)
1538 + new_idx = (new_idx + 1) % mi->n_rates;
1539
1540 - /* Don't sample the slowest rate (i.e. slowest base
1541 - * rate). We must presume that the slowest rate works
1542 - * fine, or else other management frames will also be
1543 - * failing and the link will break */
1544 - SAMPLE_TBL(mi, new_idx, col) = i + 1;
1545 + SAMPLE_TBL(mi, new_idx, col) = i;
1546 }
1547 }
1548 }
1549 @@ -542,9 +569,6 @@ minstrel_alloc(struct ieee80211_hw *hw,
1550 mp->lookaround_rate = 5;
1551 mp->lookaround_rate_mrr = 10;
1552
1553 - /* moving average weight for EWMA */
1554 - mp->ewma_level = 75;
1555 -
1556 /* maximum time that the hw is allowed to stay in one MRR segment */
1557 mp->segment_size = 6000;
1558
1559 --- a/net/mac80211/rc80211_minstrel.h
1560 +++ b/net/mac80211/rc80211_minstrel.h
1561 @@ -9,6 +9,28 @@
1562 #ifndef __RC_MINSTREL_H
1563 #define __RC_MINSTREL_H
1564
1565 +#define EWMA_LEVEL 75 /* ewma weighting factor [%] */
1566 +#define SAMPLE_COLUMNS 10 /* number of columns in sample table */
1567 +
1568 +
1569 +/* scaled fraction values */
1570 +#define MINSTREL_SCALE 16
1571 +#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div)
1572 +#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE)
1573 +
1574 +/* number of highest throughput rates to consider*/
1575 +#define MAX_THR_RATES 4
1576 +
1577 +/*
1578 + * Perform EWMA (Exponentially Weighted Moving Average) calculation
1579 + */
1580 +static inline int
1581 +minstrel_ewma(int old, int new, int weight)
1582 +{
1583 + return (new * (100 - weight) + old * weight) / 100;
1584 +}
1585 +
1586 +
1587 struct minstrel_rate {
1588 int bitrate;
1589 int rix;
1590 @@ -26,6 +48,7 @@ struct minstrel_rate {
1591 u32 attempts;
1592 u32 last_attempts;
1593 u32 last_success;
1594 + u8 sample_skipped;
1595
1596 /* parts per thousand */
1597 u32 cur_prob;
1598 @@ -45,14 +68,13 @@ struct minstrel_sta_info {
1599
1600 unsigned int lowest_rix;
1601
1602 - unsigned int max_tp_rate;
1603 - unsigned int max_tp_rate2;
1604 - unsigned int max_prob_rate;
1605 + u8 max_tp_rate[MAX_THR_RATES];
1606 + u8 max_prob_rate;
1607 unsigned int packet_count;
1608 unsigned int sample_count;
1609 int sample_deferred;
1610
1611 - unsigned int sample_idx;
1612 + unsigned int sample_row;
1613 unsigned int sample_column;
1614
1615 int n_rates;
1616 @@ -73,7 +95,6 @@ struct minstrel_priv {
1617 unsigned int cw_min;
1618 unsigned int cw_max;
1619 unsigned int max_retry;
1620 - unsigned int ewma_level;
1621 unsigned int segment_size;
1622 unsigned int update_interval;
1623 unsigned int lookaround_rate;
1624 --- a/net/mac80211/rc80211_minstrel_debugfs.c
1625 +++ b/net/mac80211/rc80211_minstrel_debugfs.c
1626 @@ -73,15 +73,17 @@ minstrel_stats_open(struct inode *inode,
1627 for (i = 0; i < mi->n_rates; i++) {
1628 struct minstrel_rate *mr = &mi->r[i];
1629
1630 - *(p++) = (i == mi->max_tp_rate) ? 'T' : ' ';
1631 - *(p++) = (i == mi->max_tp_rate2) ? 't' : ' ';
1632 + *(p++) = (i == mi->max_tp_rate[0]) ? 'A' : ' ';
1633 + *(p++) = (i == mi->max_tp_rate[1]) ? 'B' : ' ';
1634 + *(p++) = (i == mi->max_tp_rate[2]) ? 'C' : ' ';
1635 + *(p++) = (i == mi->max_tp_rate[3]) ? 'D' : ' ';
1636 *(p++) = (i == mi->max_prob_rate) ? 'P' : ' ';
1637 p += sprintf(p, "%3u%s", mr->bitrate / 2,
1638 (mr->bitrate & 1 ? ".5" : " "));
1639
1640 - tp = mr->cur_tp / ((18000 << 10) / 96);
1641 - prob = mr->cur_prob / 18;
1642 - eprob = mr->probability / 18;
1643 + tp = MINSTREL_TRUNC(mr->cur_tp / 10);
1644 + prob = MINSTREL_TRUNC(mr->cur_prob * 1000);
1645 + eprob = MINSTREL_TRUNC(mr->probability * 1000);
1646
1647 p += sprintf(p, " %6u.%1u %6u.%1u %6u.%1u "
1648 "%3u(%3u) %8llu %8llu\n",
1649 --- a/drivers/net/wireless/ath/ath9k/ath9k.h
1650 +++ b/drivers/net/wireless/ath/ath9k/ath9k.h
1651 @@ -657,11 +657,10 @@ enum sc_op_flags {
1652 struct ath_rate_table;
1653
1654 struct ath9k_vif_iter_data {
1655 - const u8 *hw_macaddr; /* phy's hardware address, set
1656 - * before starting iteration for
1657 - * valid bssid mask.
1658 - */
1659 + u8 hw_macaddr[ETH_ALEN]; /* address of the first vif */
1660 u8 mask[ETH_ALEN]; /* bssid mask */
1661 + bool has_hw_macaddr;
1662 +
1663 int naps; /* number of AP vifs */
1664 int nmeshes; /* number of mesh vifs */
1665 int nstations; /* number of station vifs */
1666 --- a/drivers/net/wireless/ath/ath9k/main.c
1667 +++ b/drivers/net/wireless/ath/ath9k/main.c
1668 @@ -835,10 +835,14 @@ static void ath9k_vif_iter(void *data, u
1669 struct ath9k_vif_iter_data *iter_data = data;
1670 int i;
1671
1672 - if (iter_data->hw_macaddr)
1673 + if (iter_data->has_hw_macaddr) {
1674 for (i = 0; i < ETH_ALEN; i++)
1675 iter_data->mask[i] &=
1676 ~(iter_data->hw_macaddr[i] ^ mac[i]);
1677 + } else {
1678 + memcpy(iter_data->hw_macaddr, mac, ETH_ALEN);
1679 + iter_data->has_hw_macaddr = true;
1680 + }
1681
1682 switch (vif->type) {
1683 case NL80211_IFTYPE_AP:
1684 @@ -887,7 +891,6 @@ void ath9k_calculate_iter_data(struct ie
1685 * together with the BSSID mask when matching addresses.
1686 */
1687 memset(iter_data, 0, sizeof(*iter_data));
1688 - iter_data->hw_macaddr = common->macaddr;
1689 memset(&iter_data->mask, 0xff, ETH_ALEN);
1690
1691 if (vif)
1692 @@ -897,6 +900,8 @@ void ath9k_calculate_iter_data(struct ie
1693 ieee80211_iterate_active_interfaces_atomic(
1694 sc->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1695 ath9k_vif_iter, iter_data);
1696 +
1697 + memcpy(common->macaddr, iter_data->hw_macaddr, ETH_ALEN);
1698 }
1699
1700 /* Called with sc->mutex held. */
1701 --- a/drivers/net/wireless/ath/ath9k/reg.h
1702 +++ b/drivers/net/wireless/ath/ath9k/reg.h
1703 @@ -1493,9 +1493,6 @@ enum {
1704 #define AR9271_RADIO_RF_RST 0x20
1705 #define AR9271_GATE_MAC_CTL 0x4000
1706
1707 -#define AR_STA_ID0 0x8000
1708 -#define AR_STA_ID1 0x8004
1709 -#define AR_STA_ID1_SADH_MASK 0x0000FFFF
1710 #define AR_STA_ID1_STA_AP 0x00010000
1711 #define AR_STA_ID1_ADHOC 0x00020000
1712 #define AR_STA_ID1_PWR_SAV 0x00040000
1713 --- a/drivers/net/wireless/ath/hw.c
1714 +++ b/drivers/net/wireless/ath/hw.c
1715 @@ -118,6 +118,12 @@
1716 void ath_hw_setbssidmask(struct ath_common *common)
1717 {
1718 void *ah = common->ah;
1719 + u32 id1;
1720 +
1721 + REG_WRITE(ah, AR_STA_ID0, get_unaligned_le32(common->macaddr));
1722 + id1 = REG_READ(ah, AR_STA_ID1) & ~AR_STA_ID1_SADH_MASK;
1723 + id1 |= get_unaligned_le16(common->macaddr + 4);
1724 + REG_WRITE(ah, AR_STA_ID1, id1);
1725
1726 REG_WRITE(ah, AR_BSSMSKL, get_unaligned_le32(common->bssidmask));
1727 REG_WRITE(ah, AR_BSSMSKU, get_unaligned_le16(common->bssidmask + 4));
1728 --- a/drivers/net/wireless/ath/reg.h
1729 +++ b/drivers/net/wireless/ath/reg.h
1730 @@ -23,6 +23,10 @@
1731 #define AR_MIBC_CMC 0x00000004
1732 #define AR_MIBC_MCS 0x00000008
1733
1734 +#define AR_STA_ID0 0x8000
1735 +#define AR_STA_ID1 0x8004
1736 +#define AR_STA_ID1_SADH_MASK 0x0000ffff
1737 +
1738 /*
1739 * BSSID mask registers. See ath_hw_set_bssid_mask()
1740 * for detailed documentation about these registers.
OpenWrt Source Repository