4 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
5 * Copyright 2002-2005, Instant802 Networks, Inc.
6 * Copyright 2005-2006, Devicescape Software, Inc.
7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 * Copyright 2007-2010, Intel Corporation
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
16 #include <linux/ieee80211.h>
17 #include <linux/export.h>
18 #include <net/mac80211.h>
19 #include "ieee80211_i.h"
22 static void __check_htcap_disable(struct ieee80211_ht_cap
*ht_capa
,
23 struct ieee80211_ht_cap
*ht_capa_mask
,
24 struct ieee80211_sta_ht_cap
*ht_cap
,
27 __le16 le_flag
= cpu_to_le16(flag
);
28 if (ht_capa_mask
->cap_info
& le_flag
) {
29 if (!(ht_capa
->cap_info
& le_flag
))
34 static void __check_htcap_enable(struct ieee80211_ht_cap
*ht_capa
,
35 struct ieee80211_ht_cap
*ht_capa_mask
,
36 struct ieee80211_sta_ht_cap
*ht_cap
,
39 __le16 le_flag
= cpu_to_le16(flag
);
41 if ((ht_capa_mask
->cap_info
& le_flag
) &&
42 (ht_capa
->cap_info
& le_flag
))
46 void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data
*sdata
,
47 struct ieee80211_sta_ht_cap
*ht_cap
)
49 struct ieee80211_ht_cap
*ht_capa
, *ht_capa_mask
;
53 if (!ht_cap
->ht_supported
)
56 switch (sdata
->vif
.type
) {
57 case NL80211_IFTYPE_STATION
:
58 ht_capa
= &sdata
->u
.mgd
.ht_capa
;
59 ht_capa_mask
= &sdata
->u
.mgd
.ht_capa_mask
;
61 case NL80211_IFTYPE_ADHOC
:
62 ht_capa
= &sdata
->u
.ibss
.ht_capa
;
63 ht_capa_mask
= &sdata
->u
.ibss
.ht_capa_mask
;
70 scaps
= (u8
*)(&ht_capa
->mcs
.rx_mask
);
71 smask
= (u8
*)(&ht_capa_mask
->mcs
.rx_mask
);
73 /* NOTE: If you add more over-rides here, update register_hw
74 * ht_capa_mod_mask logic in main.c as well.
75 * And, if this method can ever change ht_cap.ht_supported, fix
76 * the check in ieee80211_add_ht_ie.
79 /* check for HT over-rides, MCS rates first. */
80 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++) {
82 ht_cap
->mcs
.rx_mask
[i
] &= ~m
; /* turn off all masked bits */
83 /* Add back rates that are supported */
84 ht_cap
->mcs
.rx_mask
[i
] |= (m
& scaps
[i
]);
87 /* Force removal of HT-40 capabilities? */
88 __check_htcap_disable(ht_capa
, ht_capa_mask
, ht_cap
,
89 IEEE80211_HT_CAP_SUP_WIDTH_20_40
);
90 __check_htcap_disable(ht_capa
, ht_capa_mask
, ht_cap
,
91 IEEE80211_HT_CAP_SGI_40
);
93 /* Allow user to disable SGI-20 (SGI-40 is handled above) */
94 __check_htcap_disable(ht_capa
, ht_capa_mask
, ht_cap
,
95 IEEE80211_HT_CAP_SGI_20
);
97 /* Allow user to disable the max-AMSDU bit. */
98 __check_htcap_disable(ht_capa
, ht_capa_mask
, ht_cap
,
99 IEEE80211_HT_CAP_MAX_AMSDU
);
101 /* Allow user to disable LDPC */
102 __check_htcap_disable(ht_capa
, ht_capa_mask
, ht_cap
,
103 IEEE80211_HT_CAP_LDPC_CODING
);
105 /* Allow user to enable 40 MHz intolerant bit. */
106 __check_htcap_enable(ht_capa
, ht_capa_mask
, ht_cap
,
107 IEEE80211_HT_CAP_40MHZ_INTOLERANT
);
109 /* Allow user to decrease AMPDU factor */
110 if (ht_capa_mask
->ampdu_params_info
&
111 IEEE80211_HT_AMPDU_PARM_FACTOR
) {
112 u8 n
= ht_capa
->ampdu_params_info
&
113 IEEE80211_HT_AMPDU_PARM_FACTOR
;
114 if (n
< ht_cap
->ampdu_factor
)
115 ht_cap
->ampdu_factor
= n
;
118 /* Allow the user to increase AMPDU density. */
119 if (ht_capa_mask
->ampdu_params_info
&
120 IEEE80211_HT_AMPDU_PARM_DENSITY
) {
121 u8 n
= (ht_capa
->ampdu_params_info
&
122 IEEE80211_HT_AMPDU_PARM_DENSITY
)
123 >> IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT
;
124 if (n
> ht_cap
->ampdu_density
)
125 ht_cap
->ampdu_density
= n
;
130 bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data
*sdata
,
131 struct ieee80211_supported_band
*sband
,
132 const struct ieee80211_ht_cap
*ht_cap_ie
,
133 struct sta_info
*sta
)
135 struct ieee80211_sta_ht_cap ht_cap
, own_cap
;
136 u8 ampdu_info
, tx_mcs_set_cap
;
137 int i
, max_tx_streams
;
139 enum ieee80211_sta_rx_bandwidth bw
;
140 enum ieee80211_smps_mode smps_mode
;
142 memset(&ht_cap
, 0, sizeof(ht_cap
));
144 if (!ht_cap_ie
|| !sband
->ht_cap
.ht_supported
)
147 ht_cap
.ht_supported
= true;
149 own_cap
= sband
->ht_cap
;
152 * If user has specified capability over-rides, take care
153 * of that if the station we're setting up is the AP or TDLS peer that
154 * we advertised a restricted capability set to. Override
155 * our own capabilities and then use those below.
157 if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
||
158 sdata
->vif
.type
== NL80211_IFTYPE_ADHOC
)
159 ieee80211_apply_htcap_overrides(sdata
, &own_cap
);
162 * The bits listed in this expression should be
163 * the same for the peer and us, if the station
164 * advertises more then we can't use those thus
167 ht_cap
.cap
= le16_to_cpu(ht_cap_ie
->cap_info
) &
168 (own_cap
.cap
| ~(IEEE80211_HT_CAP_LDPC_CODING
|
169 IEEE80211_HT_CAP_SUP_WIDTH_20_40
|
170 IEEE80211_HT_CAP_GRN_FLD
|
171 IEEE80211_HT_CAP_SGI_20
|
172 IEEE80211_HT_CAP_SGI_40
|
173 IEEE80211_HT_CAP_DSSSCCK40
));
176 * The STBC bits are asymmetric -- if we don't have
177 * TX then mask out the peer's RX and vice versa.
179 if (!(own_cap
.cap
& IEEE80211_HT_CAP_TX_STBC
))
180 ht_cap
.cap
&= ~IEEE80211_HT_CAP_RX_STBC
;
181 if (!(own_cap
.cap
& IEEE80211_HT_CAP_RX_STBC
))
182 ht_cap
.cap
&= ~IEEE80211_HT_CAP_TX_STBC
;
184 ampdu_info
= ht_cap_ie
->ampdu_params_info
;
185 ht_cap
.ampdu_factor
=
186 ampdu_info
& IEEE80211_HT_AMPDU_PARM_FACTOR
;
187 ht_cap
.ampdu_density
=
188 (ampdu_info
& IEEE80211_HT_AMPDU_PARM_DENSITY
) >> 2;
190 /* own MCS TX capabilities */
191 tx_mcs_set_cap
= own_cap
.mcs
.tx_params
;
193 /* Copy peer MCS TX capabilities, the driver might need them. */
194 ht_cap
.mcs
.tx_params
= ht_cap_ie
->mcs
.tx_params
;
196 /* can we TX with MCS rates? */
197 if (!(tx_mcs_set_cap
& IEEE80211_HT_MCS_TX_DEFINED
))
200 /* Counting from 0, therefore +1 */
201 if (tx_mcs_set_cap
& IEEE80211_HT_MCS_TX_RX_DIFF
)
203 ((tx_mcs_set_cap
& IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK
)
204 >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT
) + 1;
206 max_tx_streams
= IEEE80211_HT_MCS_TX_MAX_STREAMS
;
209 * 802.11n-2009 20.3.5 / 20.6 says:
210 * - indices 0 to 7 and 32 are single spatial stream
211 * - 8 to 31 are multiple spatial streams using equal modulation
212 * [8..15 for two streams, 16..23 for three and 24..31 for four]
213 * - remainder are multiple spatial streams using unequal modulation
215 for (i
= 0; i
< max_tx_streams
; i
++)
216 ht_cap
.mcs
.rx_mask
[i
] =
217 own_cap
.mcs
.rx_mask
[i
] & ht_cap_ie
->mcs
.rx_mask
[i
];
219 if (tx_mcs_set_cap
& IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION
)
220 for (i
= IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE
;
221 i
< IEEE80211_HT_MCS_MASK_LEN
; i
++)
222 ht_cap
.mcs
.rx_mask
[i
] =
223 own_cap
.mcs
.rx_mask
[i
] &
224 ht_cap_ie
->mcs
.rx_mask
[i
];
226 /* handle MCS rate 32 too */
227 if (own_cap
.mcs
.rx_mask
[32/8] & ht_cap_ie
->mcs
.rx_mask
[32/8] & 1)
228 ht_cap
.mcs
.rx_mask
[32/8] |= 1;
230 /* set Rx highest rate */
231 ht_cap
.mcs
.rx_highest
= ht_cap_ie
->mcs
.rx_highest
;
234 changed
= memcmp(&sta
->sta
.ht_cap
, &ht_cap
, sizeof(ht_cap
));
236 memcpy(&sta
->sta
.ht_cap
, &ht_cap
, sizeof(ht_cap
));
238 switch (sdata
->vif
.bss_conf
.chandef
.width
) {
242 case NL80211_CHAN_WIDTH_20_NOHT
:
243 case NL80211_CHAN_WIDTH_20
:
244 bw
= IEEE80211_STA_RX_BW_20
;
246 case NL80211_CHAN_WIDTH_40
:
247 case NL80211_CHAN_WIDTH_80
:
248 case NL80211_CHAN_WIDTH_80P80
:
249 case NL80211_CHAN_WIDTH_160
:
250 bw
= ht_cap
.cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
?
251 IEEE80211_STA_RX_BW_40
: IEEE80211_STA_RX_BW_20
;
255 if (bw
!= sta
->sta
.bandwidth
)
257 sta
->sta
.bandwidth
= bw
;
259 sta
->cur_max_bandwidth
=
260 ht_cap
.cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
?
261 IEEE80211_STA_RX_BW_40
: IEEE80211_STA_RX_BW_20
;
263 switch ((ht_cap
.cap
& IEEE80211_HT_CAP_SM_PS
)
264 >> IEEE80211_HT_CAP_SM_PS_SHIFT
) {
265 case WLAN_HT_CAP_SM_PS_INVALID
:
266 case WLAN_HT_CAP_SM_PS_STATIC
:
267 smps_mode
= IEEE80211_SMPS_STATIC
;
269 case WLAN_HT_CAP_SM_PS_DYNAMIC
:
270 smps_mode
= IEEE80211_SMPS_DYNAMIC
;
272 case WLAN_HT_CAP_SM_PS_DISABLED
:
273 smps_mode
= IEEE80211_SMPS_OFF
;
277 if (smps_mode
!= sta
->sta
.smps_mode
)
279 sta
->sta
.smps_mode
= smps_mode
;
284 void ieee80211_sta_tear_down_BA_sessions(struct sta_info
*sta
,
285 enum ieee80211_agg_stop_reason reason
)
289 cancel_work_sync(&sta
->ampdu_mlme
.work
);
291 for (i
= 0; i
< IEEE80211_NUM_TIDS
; i
++) {
292 __ieee80211_stop_tx_ba_session(sta
, i
, reason
);
293 __ieee80211_stop_rx_ba_session(sta
, i
, WLAN_BACK_RECIPIENT
,
294 WLAN_REASON_QSTA_LEAVE_QBSS
,
295 reason
!= AGG_STOP_DESTROY_STA
&&
296 reason
!= AGG_STOP_PEER_REQUEST
);
300 void ieee80211_ba_session_work(struct work_struct
*work
)
302 struct sta_info
*sta
=
303 container_of(work
, struct sta_info
, ampdu_mlme
.work
);
304 struct tid_ampdu_tx
*tid_tx
;
308 * When this flag is set, new sessions should be
309 * blocked, and existing sessions will be torn
310 * down by the code that set the flag, so this
313 if (test_sta_flag(sta
, WLAN_STA_BLOCK_BA
))
316 mutex_lock(&sta
->ampdu_mlme
.mtx
);
317 for (tid
= 0; tid
< IEEE80211_NUM_TIDS
; tid
++) {
318 if (test_and_clear_bit(tid
, sta
->ampdu_mlme
.tid_rx_timer_expired
))
319 ___ieee80211_stop_rx_ba_session(
320 sta
, tid
, WLAN_BACK_RECIPIENT
,
321 WLAN_REASON_QSTA_TIMEOUT
, true);
323 if (test_and_clear_bit(tid
,
324 sta
->ampdu_mlme
.tid_rx_stop_requested
))
325 ___ieee80211_stop_rx_ba_session(
326 sta
, tid
, WLAN_BACK_RECIPIENT
,
327 WLAN_REASON_UNSPECIFIED
, true);
329 spin_lock_bh(&sta
->lock
);
331 tid_tx
= sta
->ampdu_mlme
.tid_start_tx
[tid
];
334 * Assign it over to the normal tid_tx array
335 * where it "goes live".
338 sta
->ampdu_mlme
.tid_start_tx
[tid
] = NULL
;
339 /* could there be a race? */
340 if (sta
->ampdu_mlme
.tid_tx
[tid
])
343 ieee80211_assign_tid_tx(sta
, tid
, tid_tx
);
344 spin_unlock_bh(&sta
->lock
);
346 ieee80211_tx_ba_session_handle_start(sta
, tid
);
349 spin_unlock_bh(&sta
->lock
);
351 tid_tx
= rcu_dereference_protected_tid_tx(sta
, tid
);
352 if (tid_tx
&& test_and_clear_bit(HT_AGG_STATE_WANT_STOP
,
354 ___ieee80211_stop_tx_ba_session(sta
, tid
,
355 AGG_STOP_LOCAL_REQUEST
);
357 mutex_unlock(&sta
->ampdu_mlme
.mtx
);
360 void ieee80211_send_delba(struct ieee80211_sub_if_data
*sdata
,
361 const u8
*da
, u16 tid
,
362 u16 initiator
, u16 reason_code
)
364 struct ieee80211_local
*local
= sdata
->local
;
366 struct ieee80211_mgmt
*mgmt
;
369 skb
= dev_alloc_skb(sizeof(*mgmt
) + local
->hw
.extra_tx_headroom
);
373 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
374 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
376 memcpy(mgmt
->da
, da
, ETH_ALEN
);
377 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
378 if (sdata
->vif
.type
== NL80211_IFTYPE_AP
||
379 sdata
->vif
.type
== NL80211_IFTYPE_AP_VLAN
||
380 sdata
->vif
.type
== NL80211_IFTYPE_MESH_POINT
)
381 memcpy(mgmt
->bssid
, sdata
->vif
.addr
, ETH_ALEN
);
382 else if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
)
383 memcpy(mgmt
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
384 else if (sdata
->vif
.type
== NL80211_IFTYPE_ADHOC
)
385 memcpy(mgmt
->bssid
, sdata
->u
.ibss
.bssid
, ETH_ALEN
);
387 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
388 IEEE80211_STYPE_ACTION
);
390 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.delba
));
392 mgmt
->u
.action
.category
= WLAN_CATEGORY_BACK
;
393 mgmt
->u
.action
.u
.delba
.action_code
= WLAN_ACTION_DELBA
;
394 params
= (u16
)(initiator
<< 11); /* bit 11 initiator */
395 params
|= (u16
)(tid
<< 12); /* bit 15:12 TID number */
397 mgmt
->u
.action
.u
.delba
.params
= cpu_to_le16(params
);
398 mgmt
->u
.action
.u
.delba
.reason_code
= cpu_to_le16(reason_code
);
400 ieee80211_tx_skb(sdata
, skb
);
403 void ieee80211_process_delba(struct ieee80211_sub_if_data
*sdata
,
404 struct sta_info
*sta
,
405 struct ieee80211_mgmt
*mgmt
, size_t len
)
410 params
= le16_to_cpu(mgmt
->u
.action
.u
.delba
.params
);
411 tid
= (params
& IEEE80211_DELBA_PARAM_TID_MASK
) >> 12;
412 initiator
= (params
& IEEE80211_DELBA_PARAM_INITIATOR_MASK
) >> 11;
414 ht_dbg_ratelimited(sdata
, "delba from %pM (%s) tid %d reason code %d\n",
415 mgmt
->sa
, initiator
? "initiator" : "recipient",
417 le16_to_cpu(mgmt
->u
.action
.u
.delba
.reason_code
));
419 if (initiator
== WLAN_BACK_INITIATOR
)
420 __ieee80211_stop_rx_ba_session(sta
, tid
, WLAN_BACK_INITIATOR
, 0,
423 __ieee80211_stop_tx_ba_session(sta
, tid
, AGG_STOP_PEER_REQUEST
);
426 int ieee80211_send_smps_action(struct ieee80211_sub_if_data
*sdata
,
427 enum ieee80211_smps_mode smps
, const u8
*da
,
430 struct ieee80211_local
*local
= sdata
->local
;
432 struct ieee80211_mgmt
*action_frame
;
434 /* 27 = header + category + action + smps mode */
435 skb
= dev_alloc_skb(27 + local
->hw
.extra_tx_headroom
);
439 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
440 action_frame
= (void *)skb_put(skb
, 27);
441 memcpy(action_frame
->da
, da
, ETH_ALEN
);
442 memcpy(action_frame
->sa
, sdata
->dev
->dev_addr
, ETH_ALEN
);
443 memcpy(action_frame
->bssid
, bssid
, ETH_ALEN
);
444 action_frame
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
445 IEEE80211_STYPE_ACTION
);
446 action_frame
->u
.action
.category
= WLAN_CATEGORY_HT
;
447 action_frame
->u
.action
.u
.ht_smps
.action
= WLAN_HT_ACTION_SMPS
;
449 case IEEE80211_SMPS_AUTOMATIC
:
450 case IEEE80211_SMPS_NUM_MODES
:
452 case IEEE80211_SMPS_OFF
:
453 action_frame
->u
.action
.u
.ht_smps
.smps_control
=
454 WLAN_HT_SMPS_CONTROL_DISABLED
;
456 case IEEE80211_SMPS_STATIC
:
457 action_frame
->u
.action
.u
.ht_smps
.smps_control
=
458 WLAN_HT_SMPS_CONTROL_STATIC
;
460 case IEEE80211_SMPS_DYNAMIC
:
461 action_frame
->u
.action
.u
.ht_smps
.smps_control
=
462 WLAN_HT_SMPS_CONTROL_DYNAMIC
;
466 /* we'll do more on status of this frame */
467 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_CTL_REQ_TX_STATUS
;
468 ieee80211_tx_skb(sdata
, skb
);
473 void ieee80211_request_smps_mgd_work(struct work_struct
*work
)
475 struct ieee80211_sub_if_data
*sdata
=
476 container_of(work
, struct ieee80211_sub_if_data
,
477 u
.mgd
.request_smps_work
);
480 __ieee80211_request_smps_mgd(sdata
, sdata
->u
.mgd
.driver_smps_mode
);
484 void ieee80211_request_smps_ap_work(struct work_struct
*work
)
486 struct ieee80211_sub_if_data
*sdata
=
487 container_of(work
, struct ieee80211_sub_if_data
,
488 u
.ap
.request_smps_work
);
491 if (sdata_dereference(sdata
->u
.ap
.beacon
, sdata
))
492 __ieee80211_request_smps_ap(sdata
,
493 sdata
->u
.ap
.driver_smps_mode
);
497 void ieee80211_request_smps(struct ieee80211_vif
*vif
,
498 enum ieee80211_smps_mode smps_mode
)
500 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
502 if (WARN_ON_ONCE(vif
->type
!= NL80211_IFTYPE_STATION
&&
503 vif
->type
!= NL80211_IFTYPE_AP
))
506 if (vif
->type
== NL80211_IFTYPE_STATION
) {
507 if (sdata
->u
.mgd
.driver_smps_mode
== smps_mode
)
509 sdata
->u
.mgd
.driver_smps_mode
= smps_mode
;
510 ieee80211_queue_work(&sdata
->local
->hw
,
511 &sdata
->u
.mgd
.request_smps_work
);
513 /* AUTOMATIC is meaningless in AP mode */
514 if (WARN_ON_ONCE(smps_mode
== IEEE80211_SMPS_AUTOMATIC
))
516 if (sdata
->u
.ap
.driver_smps_mode
== smps_mode
)
518 sdata
->u
.ap
.driver_smps_mode
= smps_mode
;
519 ieee80211_queue_work(&sdata
->local
->hw
,
520 &sdata
->u
.ap
.request_smps_work
);
523 /* this might change ... don't want non-open drivers using it */
524 EXPORT_SYMBOL_GPL(ieee80211_request_smps
);