Linux Audio

Check our new training course

Embedded Linux training

Mar 10-20, 2025, special US time zones
Register
Loading...
v4.17
 
  1/*
  2 * HT handling
  3 *
  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
 10 * Copyright 2017	Intel Deutschland GmbH
 11 *
 12 * This program is free software; you can redistribute it and/or modify
 13 * it under the terms of the GNU General Public License version 2 as
 14 * published by the Free Software Foundation.
 15 */
 16
 17#include <linux/ieee80211.h>
 18#include <linux/export.h>
 19#include <net/mac80211.h>
 20#include "ieee80211_i.h"
 21#include "rate.h"
 22
 23static void __check_htcap_disable(struct ieee80211_ht_cap *ht_capa,
 24				  struct ieee80211_ht_cap *ht_capa_mask,
 25				  struct ieee80211_sta_ht_cap *ht_cap,
 26				  u16 flag)
 27{
 28	__le16 le_flag = cpu_to_le16(flag);
 29	if (ht_capa_mask->cap_info & le_flag) {
 30		if (!(ht_capa->cap_info & le_flag))
 31			ht_cap->cap &= ~flag;
 32	}
 33}
 34
 35static void __check_htcap_enable(struct ieee80211_ht_cap *ht_capa,
 36				  struct ieee80211_ht_cap *ht_capa_mask,
 37				  struct ieee80211_sta_ht_cap *ht_cap,
 38				  u16 flag)
 39{
 40	__le16 le_flag = cpu_to_le16(flag);
 41
 42	if ((ht_capa_mask->cap_info & le_flag) &&
 43	    (ht_capa->cap_info & le_flag))
 44		ht_cap->cap |= flag;
 45}
 46
 47void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
 48				     struct ieee80211_sta_ht_cap *ht_cap)
 49{
 50	struct ieee80211_ht_cap *ht_capa, *ht_capa_mask;
 51	u8 *scaps, *smask;
 52	int i;
 53
 54	if (!ht_cap->ht_supported)
 55		return;
 56
 57	switch (sdata->vif.type) {
 58	case NL80211_IFTYPE_STATION:
 59		ht_capa = &sdata->u.mgd.ht_capa;
 60		ht_capa_mask = &sdata->u.mgd.ht_capa_mask;
 61		break;
 62	case NL80211_IFTYPE_ADHOC:
 63		ht_capa = &sdata->u.ibss.ht_capa;
 64		ht_capa_mask = &sdata->u.ibss.ht_capa_mask;
 65		break;
 66	default:
 67		WARN_ON_ONCE(1);
 68		return;
 69	}
 70
 71	scaps = (u8 *)(&ht_capa->mcs.rx_mask);
 72	smask = (u8 *)(&ht_capa_mask->mcs.rx_mask);
 73
 74	/* NOTE:  If you add more over-rides here, update register_hw
 75	 * ht_capa_mod_mask logic in main.c as well.
 76	 * And, if this method can ever change ht_cap.ht_supported, fix
 77	 * the check in ieee80211_add_ht_ie.
 78	 */
 79
 80	/* check for HT over-rides, MCS rates first. */
 81	for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
 82		u8 m = smask[i];
 83		ht_cap->mcs.rx_mask[i] &= ~m; /* turn off all masked bits */
 84		/* Add back rates that are supported */
 85		ht_cap->mcs.rx_mask[i] |= (m & scaps[i]);
 86	}
 87
 88	/* Force removal of HT-40 capabilities? */
 89	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
 90			      IEEE80211_HT_CAP_SUP_WIDTH_20_40);
 91	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
 92			      IEEE80211_HT_CAP_SGI_40);
 93
 94	/* Allow user to disable SGI-20 (SGI-40 is handled above) */
 95	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
 96			      IEEE80211_HT_CAP_SGI_20);
 97
 98	/* Allow user to disable the max-AMSDU bit. */
 99	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
100			      IEEE80211_HT_CAP_MAX_AMSDU);
101
102	/* Allow user to disable LDPC */
103	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
104			      IEEE80211_HT_CAP_LDPC_CODING);
105
106	/* Allow user to enable 40 MHz intolerant bit. */
107	__check_htcap_enable(ht_capa, ht_capa_mask, ht_cap,
108			     IEEE80211_HT_CAP_40MHZ_INTOLERANT);
109
 
 
 
 
 
 
 
 
 
110	/* Allow user to decrease AMPDU factor */
111	if (ht_capa_mask->ampdu_params_info &
112	    IEEE80211_HT_AMPDU_PARM_FACTOR) {
113		u8 n = ht_capa->ampdu_params_info &
114		       IEEE80211_HT_AMPDU_PARM_FACTOR;
115		if (n < ht_cap->ampdu_factor)
116			ht_cap->ampdu_factor = n;
117	}
118
119	/* Allow the user to increase AMPDU density. */
120	if (ht_capa_mask->ampdu_params_info &
121	    IEEE80211_HT_AMPDU_PARM_DENSITY) {
122		u8 n = (ht_capa->ampdu_params_info &
123			IEEE80211_HT_AMPDU_PARM_DENSITY)
124			>> IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT;
125		if (n > ht_cap->ampdu_density)
126			ht_cap->ampdu_density = n;
127	}
128}
129
130
131bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
132				       struct ieee80211_supported_band *sband,
133				       const struct ieee80211_ht_cap *ht_cap_ie,
134				       struct sta_info *sta)
135{
 
 
136	struct ieee80211_sta_ht_cap ht_cap, own_cap;
137	u8 ampdu_info, tx_mcs_set_cap;
138	int i, max_tx_streams;
139	bool changed;
140	enum ieee80211_sta_rx_bandwidth bw;
141	enum ieee80211_smps_mode smps_mode;
142
143	memset(&ht_cap, 0, sizeof(ht_cap));
144
145	if (!ht_cap_ie || !sband->ht_cap.ht_supported)
146		goto apply;
147
148	ht_cap.ht_supported = true;
149
150	own_cap = sband->ht_cap;
151
152	/*
153	 * If user has specified capability over-rides, take care
154	 * of that if the station we're setting up is the AP or TDLS peer that
155	 * we advertised a restricted capability set to. Override
156	 * our own capabilities and then use those below.
157	 */
158	if (sdata->vif.type == NL80211_IFTYPE_STATION ||
159	    sdata->vif.type == NL80211_IFTYPE_ADHOC)
160		ieee80211_apply_htcap_overrides(sdata, &own_cap);
161
162	/*
163	 * The bits listed in this expression should be
164	 * the same for the peer and us, if the station
165	 * advertises more then we can't use those thus
166	 * we mask them out.
167	 */
168	ht_cap.cap = le16_to_cpu(ht_cap_ie->cap_info) &
169		(own_cap.cap | ~(IEEE80211_HT_CAP_LDPC_CODING |
170				 IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
171				 IEEE80211_HT_CAP_GRN_FLD |
172				 IEEE80211_HT_CAP_SGI_20 |
173				 IEEE80211_HT_CAP_SGI_40 |
174				 IEEE80211_HT_CAP_DSSSCCK40));
175
176	/*
177	 * The STBC bits are asymmetric -- if we don't have
178	 * TX then mask out the peer's RX and vice versa.
179	 */
180	if (!(own_cap.cap & IEEE80211_HT_CAP_TX_STBC))
181		ht_cap.cap &= ~IEEE80211_HT_CAP_RX_STBC;
182	if (!(own_cap.cap & IEEE80211_HT_CAP_RX_STBC))
183		ht_cap.cap &= ~IEEE80211_HT_CAP_TX_STBC;
184
185	ampdu_info = ht_cap_ie->ampdu_params_info;
186	ht_cap.ampdu_factor =
187		ampdu_info & IEEE80211_HT_AMPDU_PARM_FACTOR;
188	ht_cap.ampdu_density =
189		(ampdu_info & IEEE80211_HT_AMPDU_PARM_DENSITY) >> 2;
190
191	/* own MCS TX capabilities */
192	tx_mcs_set_cap = own_cap.mcs.tx_params;
193
194	/* Copy peer MCS TX capabilities, the driver might need them. */
195	ht_cap.mcs.tx_params = ht_cap_ie->mcs.tx_params;
196
197	/* can we TX with MCS rates? */
198	if (!(tx_mcs_set_cap & IEEE80211_HT_MCS_TX_DEFINED))
199		goto apply;
200
201	/* Counting from 0, therefore +1 */
202	if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_RX_DIFF)
203		max_tx_streams =
204			((tx_mcs_set_cap & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
205				>> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1;
206	else
207		max_tx_streams = IEEE80211_HT_MCS_TX_MAX_STREAMS;
208
209	/*
210	 * 802.11n-2009 20.3.5 / 20.6 says:
211	 * - indices 0 to 7 and 32 are single spatial stream
212	 * - 8 to 31 are multiple spatial streams using equal modulation
213	 *   [8..15 for two streams, 16..23 for three and 24..31 for four]
214	 * - remainder are multiple spatial streams using unequal modulation
215	 */
216	for (i = 0; i < max_tx_streams; i++)
217		ht_cap.mcs.rx_mask[i] =
218			own_cap.mcs.rx_mask[i] & ht_cap_ie->mcs.rx_mask[i];
219
220	if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION)
221		for (i = IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE;
222		     i < IEEE80211_HT_MCS_MASK_LEN; i++)
223			ht_cap.mcs.rx_mask[i] =
224				own_cap.mcs.rx_mask[i] &
225					ht_cap_ie->mcs.rx_mask[i];
226
227	/* handle MCS rate 32 too */
228	if (own_cap.mcs.rx_mask[32/8] & ht_cap_ie->mcs.rx_mask[32/8] & 1)
229		ht_cap.mcs.rx_mask[32/8] |= 1;
230
231	/* set Rx highest rate */
232	ht_cap.mcs.rx_highest = ht_cap_ie->mcs.rx_highest;
233
234	if (ht_cap.cap & IEEE80211_HT_CAP_MAX_AMSDU)
235		sta->sta.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_7935;
236	else
237		sta->sta.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_3839;
 
 
238
239 apply:
240	changed = memcmp(&sta->sta.ht_cap, &ht_cap, sizeof(ht_cap));
241
242	memcpy(&sta->sta.ht_cap, &ht_cap, sizeof(ht_cap));
243
244	switch (sdata->vif.bss_conf.chandef.width) {
 
 
 
 
 
 
 
245	default:
246		WARN_ON_ONCE(1);
247		/* fall through */
248	case NL80211_CHAN_WIDTH_20_NOHT:
249	case NL80211_CHAN_WIDTH_20:
250		bw = IEEE80211_STA_RX_BW_20;
251		break;
252	case NL80211_CHAN_WIDTH_40:
253	case NL80211_CHAN_WIDTH_80:
254	case NL80211_CHAN_WIDTH_80P80:
255	case NL80211_CHAN_WIDTH_160:
 
256		bw = ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
257				IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20;
258		break;
259	}
 
260
261	sta->sta.bandwidth = bw;
262
263	sta->cur_max_bandwidth =
264		ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
265				IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20;
266
267	switch ((ht_cap.cap & IEEE80211_HT_CAP_SM_PS)
268			>> IEEE80211_HT_CAP_SM_PS_SHIFT) {
269	case WLAN_HT_CAP_SM_PS_INVALID:
270	case WLAN_HT_CAP_SM_PS_STATIC:
271		smps_mode = IEEE80211_SMPS_STATIC;
272		break;
273	case WLAN_HT_CAP_SM_PS_DYNAMIC:
274		smps_mode = IEEE80211_SMPS_DYNAMIC;
275		break;
276	case WLAN_HT_CAP_SM_PS_DISABLED:
277		smps_mode = IEEE80211_SMPS_OFF;
278		break;
279	}
 
 
 
 
280
281	if (smps_mode != sta->sta.smps_mode)
282		changed = true;
283	sta->sta.smps_mode = smps_mode;
 
 
 
284
285	return changed;
286}
287
288void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta,
289					 enum ieee80211_agg_stop_reason reason)
290{
291	int i;
292
293	mutex_lock(&sta->ampdu_mlme.mtx);
294	for (i = 0; i <  IEEE80211_NUM_TIDS; i++)
295		___ieee80211_stop_rx_ba_session(sta, i, WLAN_BACK_RECIPIENT,
296						WLAN_REASON_QSTA_LEAVE_QBSS,
297						reason != AGG_STOP_DESTROY_STA &&
298						reason != AGG_STOP_PEER_REQUEST);
299
300	for (i = 0; i <  IEEE80211_NUM_TIDS; i++)
301		___ieee80211_stop_tx_ba_session(sta, i, reason);
302	mutex_unlock(&sta->ampdu_mlme.mtx);
 
 
303
304	/* stopping might queue the work again - so cancel only afterwards */
305	cancel_work_sync(&sta->ampdu_mlme.work);
306
307	/*
308	 * In case the tear down is part of a reconfigure due to HW restart
309	 * request, it is possible that the low level driver requested to stop
310	 * the BA session, so handle it to properly clean tid_tx data.
311	 */
312	mutex_lock(&sta->ampdu_mlme.mtx);
313	for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
314		struct tid_ampdu_tx *tid_tx =
315			rcu_dereference_protected_tid_tx(sta, i);
316
317		if (!tid_tx)
318			continue;
 
319
320		if (test_and_clear_bit(HT_AGG_STATE_STOP_CB, &tid_tx->state))
321			ieee80211_stop_tx_ba_cb(sta, i, tid_tx);
 
 
 
 
322	}
323	mutex_unlock(&sta->ampdu_mlme.mtx);
324}
325
326void ieee80211_ba_session_work(struct work_struct *work)
327{
328	struct sta_info *sta =
329		container_of(work, struct sta_info, ampdu_mlme.work);
330	struct tid_ampdu_tx *tid_tx;
 
331	int tid;
332
333	/*
334	 * When this flag is set, new sessions should be
335	 * blocked, and existing sessions will be torn
336	 * down by the code that set the flag, so this
337	 * need not run.
338	 */
339	if (test_sta_flag(sta, WLAN_STA_BLOCK_BA))
340		return;
341
342	mutex_lock(&sta->ampdu_mlme.mtx);
343	for (tid = 0; tid < IEEE80211_NUM_TIDS; tid++) {
344		if (test_and_clear_bit(tid, sta->ampdu_mlme.tid_rx_timer_expired))
345			___ieee80211_stop_rx_ba_session(
346				sta, tid, WLAN_BACK_RECIPIENT,
347				WLAN_REASON_QSTA_TIMEOUT, true);
348
349		if (test_and_clear_bit(tid,
350				       sta->ampdu_mlme.tid_rx_stop_requested))
351			___ieee80211_stop_rx_ba_session(
352				sta, tid, WLAN_BACK_RECIPIENT,
353				WLAN_REASON_UNSPECIFIED, true);
354
355		if (test_and_clear_bit(tid,
 
356				       sta->ampdu_mlme.tid_rx_manage_offl))
357			___ieee80211_start_rx_ba_session(sta, 0, 0, 0, 1, tid,
358							 IEEE80211_MAX_AMPDU_BUF,
359							 false, true);
360
361		if (test_and_clear_bit(tid + IEEE80211_NUM_TIDS,
362				       sta->ampdu_mlme.tid_rx_manage_offl))
363			___ieee80211_stop_rx_ba_session(
364				sta, tid, WLAN_BACK_RECIPIENT,
365				0, false);
366
367		spin_lock_bh(&sta->lock);
368
369		tid_tx = sta->ampdu_mlme.tid_start_tx[tid];
370		if (tid_tx) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
371			/*
372			 * Assign it over to the normal tid_tx array
373			 * where it "goes live".
374			 */
375
376			sta->ampdu_mlme.tid_start_tx[tid] = NULL;
377			/* could there be a race? */
378			if (sta->ampdu_mlme.tid_tx[tid])
379				kfree(tid_tx);
380			else
381				ieee80211_assign_tid_tx(sta, tid, tid_tx);
382			spin_unlock_bh(&sta->lock);
383
384			ieee80211_tx_ba_session_handle_start(sta, tid);
385			continue;
386		}
387		spin_unlock_bh(&sta->lock);
388
389		tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
390		if (!tid_tx)
391			continue;
392
393		if (test_and_clear_bit(HT_AGG_STATE_START_CB, &tid_tx->state))
 
394			ieee80211_start_tx_ba_cb(sta, tid, tid_tx);
395		if (test_and_clear_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state))
396			___ieee80211_stop_tx_ba_session(sta, tid,
397							AGG_STOP_LOCAL_REQUEST);
398		if (test_and_clear_bit(HT_AGG_STATE_STOP_CB, &tid_tx->state))
399			ieee80211_stop_tx_ba_cb(sta, tid, tid_tx);
400	}
401	mutex_unlock(&sta->ampdu_mlme.mtx);
402}
403
404void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
405			  const u8 *da, u16 tid,
406			  u16 initiator, u16 reason_code)
407{
408	struct ieee80211_local *local = sdata->local;
409	struct sk_buff *skb;
410	struct ieee80211_mgmt *mgmt;
411	u16 params;
412
413	skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
414	if (!skb)
415		return;
416
417	skb_reserve(skb, local->hw.extra_tx_headroom);
418	mgmt = skb_put_zero(skb, 24);
419	memcpy(mgmt->da, da, ETH_ALEN);
420	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
421	if (sdata->vif.type == NL80211_IFTYPE_AP ||
422	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
423	    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
424		memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
425	else if (sdata->vif.type == NL80211_IFTYPE_STATION)
426		memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
427	else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
428		memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
429
430	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
431					  IEEE80211_STYPE_ACTION);
432
433	skb_put(skb, 1 + sizeof(mgmt->u.action.u.delba));
434
435	mgmt->u.action.category = WLAN_CATEGORY_BACK;
436	mgmt->u.action.u.delba.action_code = WLAN_ACTION_DELBA;
437	params = (u16)(initiator << 11); 	/* bit 11 initiator */
438	params |= (u16)(tid << 12); 		/* bit 15:12 TID number */
439
440	mgmt->u.action.u.delba.params = cpu_to_le16(params);
441	mgmt->u.action.u.delba.reason_code = cpu_to_le16(reason_code);
442
443	ieee80211_tx_skb(sdata, skb);
444}
445
446void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,
447			     struct sta_info *sta,
448			     struct ieee80211_mgmt *mgmt, size_t len)
449{
450	u16 tid, params;
451	u16 initiator;
452
453	params = le16_to_cpu(mgmt->u.action.u.delba.params);
454	tid = (params & IEEE80211_DELBA_PARAM_TID_MASK) >> 12;
455	initiator = (params & IEEE80211_DELBA_PARAM_INITIATOR_MASK) >> 11;
456
457	ht_dbg_ratelimited(sdata, "delba from %pM (%s) tid %d reason code %d\n",
458			   mgmt->sa, initiator ? "initiator" : "recipient",
459			   tid,
460			   le16_to_cpu(mgmt->u.action.u.delba.reason_code));
461
462	if (initiator == WLAN_BACK_INITIATOR)
463		__ieee80211_stop_rx_ba_session(sta, tid, WLAN_BACK_INITIATOR, 0,
464					       true);
465	else
466		__ieee80211_stop_tx_ba_session(sta, tid, AGG_STOP_PEER_REQUEST);
467}
468
469enum nl80211_smps_mode
470ieee80211_smps_mode_to_smps_mode(enum ieee80211_smps_mode smps)
471{
472	switch (smps) {
473	case IEEE80211_SMPS_OFF:
474		return NL80211_SMPS_OFF;
475	case IEEE80211_SMPS_STATIC:
476		return NL80211_SMPS_STATIC;
477	case IEEE80211_SMPS_DYNAMIC:
478		return NL80211_SMPS_DYNAMIC;
479	default:
480		return NL80211_SMPS_OFF;
481	}
482}
483
484int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
485			       enum ieee80211_smps_mode smps, const u8 *da,
486			       const u8 *bssid)
487{
488	struct ieee80211_local *local = sdata->local;
489	struct sk_buff *skb;
490	struct ieee80211_mgmt *action_frame;
 
 
491
492	/* 27 = header + category + action + smps mode */
493	skb = dev_alloc_skb(27 + local->hw.extra_tx_headroom);
494	if (!skb)
495		return -ENOMEM;
496
497	skb_reserve(skb, local->hw.extra_tx_headroom);
498	action_frame = skb_put(skb, 27);
499	memcpy(action_frame->da, da, ETH_ALEN);
500	memcpy(action_frame->sa, sdata->dev->dev_addr, ETH_ALEN);
501	memcpy(action_frame->bssid, bssid, ETH_ALEN);
502	action_frame->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
503						  IEEE80211_STYPE_ACTION);
504	action_frame->u.action.category = WLAN_CATEGORY_HT;
505	action_frame->u.action.u.ht_smps.action = WLAN_HT_ACTION_SMPS;
506	switch (smps) {
507	case IEEE80211_SMPS_AUTOMATIC:
508	case IEEE80211_SMPS_NUM_MODES:
509		WARN_ON(1);
510		/* fall through */
 
511	case IEEE80211_SMPS_OFF:
512		action_frame->u.action.u.ht_smps.smps_control =
513				WLAN_HT_SMPS_CONTROL_DISABLED;
514		break;
515	case IEEE80211_SMPS_STATIC:
516		action_frame->u.action.u.ht_smps.smps_control =
517				WLAN_HT_SMPS_CONTROL_STATIC;
518		break;
519	case IEEE80211_SMPS_DYNAMIC:
520		action_frame->u.action.u.ht_smps.smps_control =
521				WLAN_HT_SMPS_CONTROL_DYNAMIC;
522		break;
523	}
524
525	/* we'll do more on status of this frame */
526	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;
527	ieee80211_tx_skb(sdata, skb);
 
 
 
 
 
528
529	return 0;
530}
531
532void ieee80211_request_smps_mgd_work(struct work_struct *work)
533{
534	struct ieee80211_sub_if_data *sdata =
535		container_of(work, struct ieee80211_sub_if_data,
536			     u.mgd.request_smps_work);
537
538	sdata_lock(sdata);
539	__ieee80211_request_smps_mgd(sdata, sdata->u.mgd.driver_smps_mode);
540	sdata_unlock(sdata);
541}
542
543void ieee80211_request_smps_ap_work(struct work_struct *work)
544{
545	struct ieee80211_sub_if_data *sdata =
546		container_of(work, struct ieee80211_sub_if_data,
547			     u.ap.request_smps_work);
548
549	sdata_lock(sdata);
550	if (sdata_dereference(sdata->u.ap.beacon, sdata))
551		__ieee80211_request_smps_ap(sdata,
552					    sdata->u.ap.driver_smps_mode);
553	sdata_unlock(sdata);
554}
555
556void ieee80211_request_smps(struct ieee80211_vif *vif,
557			    enum ieee80211_smps_mode smps_mode)
558{
559	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 
560
561	if (WARN_ON_ONCE(vif->type != NL80211_IFTYPE_STATION &&
562			 vif->type != NL80211_IFTYPE_AP))
563		return;
564
565	if (vif->type == NL80211_IFTYPE_STATION) {
566		if (sdata->u.mgd.driver_smps_mode == smps_mode)
567			return;
568		sdata->u.mgd.driver_smps_mode = smps_mode;
569		ieee80211_queue_work(&sdata->local->hw,
570				     &sdata->u.mgd.request_smps_work);
571	} else {
572		/* AUTOMATIC is meaningless in AP mode */
573		if (WARN_ON_ONCE(smps_mode == IEEE80211_SMPS_AUTOMATIC))
574			return;
575		if (sdata->u.ap.driver_smps_mode == smps_mode)
576			return;
577		sdata->u.ap.driver_smps_mode = smps_mode;
578		ieee80211_queue_work(&sdata->local->hw,
579				     &sdata->u.ap.request_smps_work);
580	}
581}
582/* this might change ... don't want non-open drivers using it */
583EXPORT_SYMBOL_GPL(ieee80211_request_smps);
v6.9.4
  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * HT handling
  4 *
  5 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
  6 * Copyright 2002-2005, Instant802 Networks, Inc.
  7 * Copyright 2005-2006, Devicescape Software, Inc.
  8 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
  9 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
 10 * Copyright 2007-2010, Intel Corporation
 11 * Copyright 2017	Intel Deutschland GmbH
 12 * Copyright(c) 2020-2024 Intel Corporation
 
 
 
 13 */
 14
 15#include <linux/ieee80211.h>
 16#include <linux/export.h>
 17#include <net/mac80211.h>
 18#include "ieee80211_i.h"
 19#include "rate.h"
 20
 21static void __check_htcap_disable(struct ieee80211_ht_cap *ht_capa,
 22				  struct ieee80211_ht_cap *ht_capa_mask,
 23				  struct ieee80211_sta_ht_cap *ht_cap,
 24				  u16 flag)
 25{
 26	__le16 le_flag = cpu_to_le16(flag);
 27	if (ht_capa_mask->cap_info & le_flag) {
 28		if (!(ht_capa->cap_info & le_flag))
 29			ht_cap->cap &= ~flag;
 30	}
 31}
 32
 33static void __check_htcap_enable(struct ieee80211_ht_cap *ht_capa,
 34				  struct ieee80211_ht_cap *ht_capa_mask,
 35				  struct ieee80211_sta_ht_cap *ht_cap,
 36				  u16 flag)
 37{
 38	__le16 le_flag = cpu_to_le16(flag);
 39
 40	if ((ht_capa_mask->cap_info & le_flag) &&
 41	    (ht_capa->cap_info & le_flag))
 42		ht_cap->cap |= flag;
 43}
 44
 45void ieee80211_apply_htcap_overrides(struct ieee80211_sub_if_data *sdata,
 46				     struct ieee80211_sta_ht_cap *ht_cap)
 47{
 48	struct ieee80211_ht_cap *ht_capa, *ht_capa_mask;
 49	u8 *scaps, *smask;
 50	int i;
 51
 52	if (!ht_cap->ht_supported)
 53		return;
 54
 55	switch (sdata->vif.type) {
 56	case NL80211_IFTYPE_STATION:
 57		ht_capa = &sdata->u.mgd.ht_capa;
 58		ht_capa_mask = &sdata->u.mgd.ht_capa_mask;
 59		break;
 60	case NL80211_IFTYPE_ADHOC:
 61		ht_capa = &sdata->u.ibss.ht_capa;
 62		ht_capa_mask = &sdata->u.ibss.ht_capa_mask;
 63		break;
 64	default:
 65		WARN_ON_ONCE(1);
 66		return;
 67	}
 68
 69	scaps = (u8 *)(&ht_capa->mcs.rx_mask);
 70	smask = (u8 *)(&ht_capa_mask->mcs.rx_mask);
 71
 72	/* NOTE:  If you add more over-rides here, update register_hw
 73	 * ht_capa_mod_mask logic in main.c as well.
 74	 * And, if this method can ever change ht_cap.ht_supported, fix
 75	 * the check in ieee80211_add_ht_ie.
 76	 */
 77
 78	/* check for HT over-rides, MCS rates first. */
 79	for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
 80		u8 m = smask[i];
 81		ht_cap->mcs.rx_mask[i] &= ~m; /* turn off all masked bits */
 82		/* Add back rates that are supported */
 83		ht_cap->mcs.rx_mask[i] |= (m & scaps[i]);
 84	}
 85
 86	/* Force removal of HT-40 capabilities? */
 87	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
 88			      IEEE80211_HT_CAP_SUP_WIDTH_20_40);
 89	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
 90			      IEEE80211_HT_CAP_SGI_40);
 91
 92	/* Allow user to disable SGI-20 (SGI-40 is handled above) */
 93	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
 94			      IEEE80211_HT_CAP_SGI_20);
 95
 96	/* Allow user to disable the max-AMSDU bit. */
 97	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
 98			      IEEE80211_HT_CAP_MAX_AMSDU);
 99
100	/* Allow user to disable LDPC */
101	__check_htcap_disable(ht_capa, ht_capa_mask, ht_cap,
102			      IEEE80211_HT_CAP_LDPC_CODING);
103
104	/* Allow user to enable 40 MHz intolerant bit. */
105	__check_htcap_enable(ht_capa, ht_capa_mask, ht_cap,
106			     IEEE80211_HT_CAP_40MHZ_INTOLERANT);
107
108	/* Allow user to enable TX STBC bit  */
109	__check_htcap_enable(ht_capa, ht_capa_mask, ht_cap,
110			     IEEE80211_HT_CAP_TX_STBC);
111
112	/* Allow user to configure RX STBC bits */
113	if (ht_capa_mask->cap_info & cpu_to_le16(IEEE80211_HT_CAP_RX_STBC))
114		ht_cap->cap |= le16_to_cpu(ht_capa->cap_info) &
115					IEEE80211_HT_CAP_RX_STBC;
116
117	/* Allow user to decrease AMPDU factor */
118	if (ht_capa_mask->ampdu_params_info &
119	    IEEE80211_HT_AMPDU_PARM_FACTOR) {
120		u8 n = ht_capa->ampdu_params_info &
121		       IEEE80211_HT_AMPDU_PARM_FACTOR;
122		if (n < ht_cap->ampdu_factor)
123			ht_cap->ampdu_factor = n;
124	}
125
126	/* Allow the user to increase AMPDU density. */
127	if (ht_capa_mask->ampdu_params_info &
128	    IEEE80211_HT_AMPDU_PARM_DENSITY) {
129		u8 n = (ht_capa->ampdu_params_info &
130			IEEE80211_HT_AMPDU_PARM_DENSITY)
131			>> IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT;
132		if (n > ht_cap->ampdu_density)
133			ht_cap->ampdu_density = n;
134	}
135}
136
137
138bool ieee80211_ht_cap_ie_to_sta_ht_cap(struct ieee80211_sub_if_data *sdata,
139				       struct ieee80211_supported_band *sband,
140				       const struct ieee80211_ht_cap *ht_cap_ie,
141				       struct link_sta_info *link_sta)
142{
143	struct ieee80211_bss_conf *link_conf;
144	struct sta_info *sta = link_sta->sta;
145	struct ieee80211_sta_ht_cap ht_cap, own_cap;
146	u8 ampdu_info, tx_mcs_set_cap;
147	int i, max_tx_streams;
148	bool changed;
149	enum ieee80211_sta_rx_bandwidth bw;
150	enum nl80211_chan_width width;
151
152	memset(&ht_cap, 0, sizeof(ht_cap));
153
154	if (!ht_cap_ie || !sband->ht_cap.ht_supported)
155		goto apply;
156
157	ht_cap.ht_supported = true;
158
159	own_cap = sband->ht_cap;
160
161	/*
162	 * If user has specified capability over-rides, take care
163	 * of that if the station we're setting up is the AP or TDLS peer that
164	 * we advertised a restricted capability set to. Override
165	 * our own capabilities and then use those below.
166	 */
167	if (sdata->vif.type == NL80211_IFTYPE_STATION ||
168	    sdata->vif.type == NL80211_IFTYPE_ADHOC)
169		ieee80211_apply_htcap_overrides(sdata, &own_cap);
170
171	/*
172	 * The bits listed in this expression should be
173	 * the same for the peer and us, if the station
174	 * advertises more then we can't use those thus
175	 * we mask them out.
176	 */
177	ht_cap.cap = le16_to_cpu(ht_cap_ie->cap_info) &
178		(own_cap.cap | ~(IEEE80211_HT_CAP_LDPC_CODING |
179				 IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
180				 IEEE80211_HT_CAP_GRN_FLD |
181				 IEEE80211_HT_CAP_SGI_20 |
182				 IEEE80211_HT_CAP_SGI_40 |
183				 IEEE80211_HT_CAP_DSSSCCK40));
184
185	/*
186	 * The STBC bits are asymmetric -- if we don't have
187	 * TX then mask out the peer's RX and vice versa.
188	 */
189	if (!(own_cap.cap & IEEE80211_HT_CAP_TX_STBC))
190		ht_cap.cap &= ~IEEE80211_HT_CAP_RX_STBC;
191	if (!(own_cap.cap & IEEE80211_HT_CAP_RX_STBC))
192		ht_cap.cap &= ~IEEE80211_HT_CAP_TX_STBC;
193
194	ampdu_info = ht_cap_ie->ampdu_params_info;
195	ht_cap.ampdu_factor =
196		ampdu_info & IEEE80211_HT_AMPDU_PARM_FACTOR;
197	ht_cap.ampdu_density =
198		(ampdu_info & IEEE80211_HT_AMPDU_PARM_DENSITY) >> 2;
199
200	/* own MCS TX capabilities */
201	tx_mcs_set_cap = own_cap.mcs.tx_params;
202
203	/* Copy peer MCS TX capabilities, the driver might need them. */
204	ht_cap.mcs.tx_params = ht_cap_ie->mcs.tx_params;
205
206	/* can we TX with MCS rates? */
207	if (!(tx_mcs_set_cap & IEEE80211_HT_MCS_TX_DEFINED))
208		goto apply;
209
210	/* Counting from 0, therefore +1 */
211	if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_RX_DIFF)
212		max_tx_streams =
213			((tx_mcs_set_cap & IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
214				>> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT) + 1;
215	else
216		max_tx_streams = IEEE80211_HT_MCS_TX_MAX_STREAMS;
217
218	/*
219	 * 802.11n-2009 20.3.5 / 20.6 says:
220	 * - indices 0 to 7 and 32 are single spatial stream
221	 * - 8 to 31 are multiple spatial streams using equal modulation
222	 *   [8..15 for two streams, 16..23 for three and 24..31 for four]
223	 * - remainder are multiple spatial streams using unequal modulation
224	 */
225	for (i = 0; i < max_tx_streams; i++)
226		ht_cap.mcs.rx_mask[i] =
227			own_cap.mcs.rx_mask[i] & ht_cap_ie->mcs.rx_mask[i];
228
229	if (tx_mcs_set_cap & IEEE80211_HT_MCS_TX_UNEQUAL_MODULATION)
230		for (i = IEEE80211_HT_MCS_UNEQUAL_MODULATION_START_BYTE;
231		     i < IEEE80211_HT_MCS_MASK_LEN; i++)
232			ht_cap.mcs.rx_mask[i] =
233				own_cap.mcs.rx_mask[i] &
234					ht_cap_ie->mcs.rx_mask[i];
235
236	/* handle MCS rate 32 too */
237	if (own_cap.mcs.rx_mask[32/8] & ht_cap_ie->mcs.rx_mask[32/8] & 1)
238		ht_cap.mcs.rx_mask[32/8] |= 1;
239
240	/* set Rx highest rate */
241	ht_cap.mcs.rx_highest = ht_cap_ie->mcs.rx_highest;
242
243	if (ht_cap.cap & IEEE80211_HT_CAP_MAX_AMSDU)
244		link_sta->pub->agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_7935;
245	else
246		link_sta->pub->agg.max_amsdu_len = IEEE80211_MAX_MPDU_LEN_HT_3839;
247
248	ieee80211_sta_recalc_aggregates(&sta->sta);
249
250 apply:
251	changed = memcmp(&link_sta->pub->ht_cap, &ht_cap, sizeof(ht_cap));
252
253	memcpy(&link_sta->pub->ht_cap, &ht_cap, sizeof(ht_cap));
254
255	rcu_read_lock();
256	link_conf = rcu_dereference(sdata->vif.link_conf[link_sta->link_id]);
257	if (WARN_ON(!link_conf))
258		width = NL80211_CHAN_WIDTH_20_NOHT;
259	else
260		width = link_conf->chanreq.oper.width;
261
262	switch (width) {
263	default:
264		WARN_ON_ONCE(1);
265		fallthrough;
266	case NL80211_CHAN_WIDTH_20_NOHT:
267	case NL80211_CHAN_WIDTH_20:
268		bw = IEEE80211_STA_RX_BW_20;
269		break;
270	case NL80211_CHAN_WIDTH_40:
271	case NL80211_CHAN_WIDTH_80:
272	case NL80211_CHAN_WIDTH_80P80:
273	case NL80211_CHAN_WIDTH_160:
274	case NL80211_CHAN_WIDTH_320:
275		bw = ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
276				IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20;
277		break;
278	}
279	rcu_read_unlock();
280
281	link_sta->pub->bandwidth = bw;
282
283	link_sta->cur_max_bandwidth =
284		ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 ?
285				IEEE80211_STA_RX_BW_40 : IEEE80211_STA_RX_BW_20;
286
287	if (sta->sdata->vif.type == NL80211_IFTYPE_AP ||
288	    sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
289		enum ieee80211_smps_mode smps_mode;
290
291		switch ((ht_cap.cap & IEEE80211_HT_CAP_SM_PS)
292				>> IEEE80211_HT_CAP_SM_PS_SHIFT) {
293		case WLAN_HT_CAP_SM_PS_INVALID:
294		case WLAN_HT_CAP_SM_PS_STATIC:
295			smps_mode = IEEE80211_SMPS_STATIC;
296			break;
297		case WLAN_HT_CAP_SM_PS_DYNAMIC:
298			smps_mode = IEEE80211_SMPS_DYNAMIC;
299			break;
300		case WLAN_HT_CAP_SM_PS_DISABLED:
301			smps_mode = IEEE80211_SMPS_OFF;
302			break;
303		}
304
305		if (smps_mode != link_sta->pub->smps_mode)
306			changed = true;
307		link_sta->pub->smps_mode = smps_mode;
308	} else {
309		link_sta->pub->smps_mode = IEEE80211_SMPS_OFF;
310	}
311
312	return changed;
313}
314
315void ieee80211_sta_tear_down_BA_sessions(struct sta_info *sta,
316					 enum ieee80211_agg_stop_reason reason)
317{
318	int i;
319
320	lockdep_assert_wiphy(sta->local->hw.wiphy);
 
 
 
 
 
321
322	for (i = 0; i <  IEEE80211_NUM_TIDS; i++)
323		__ieee80211_stop_rx_ba_session(sta, i, WLAN_BACK_RECIPIENT,
324					       WLAN_REASON_QSTA_LEAVE_QBSS,
325					       reason != AGG_STOP_DESTROY_STA &&
326					       reason != AGG_STOP_PEER_REQUEST);
327
328	for (i = 0; i <  IEEE80211_NUM_TIDS; i++)
329		__ieee80211_stop_tx_ba_session(sta, i, reason);
330
331	/*
332	 * In case the tear down is part of a reconfigure due to HW restart
333	 * request, it is possible that the low level driver requested to stop
334	 * the BA session, so handle it to properly clean tid_tx data.
335	 */
336	if(reason == AGG_STOP_DESTROY_STA) {
337		wiphy_work_cancel(sta->local->hw.wiphy, &sta->ampdu_mlme.work);
 
 
338
339		for (i = 0; i < IEEE80211_NUM_TIDS; i++) {
340			struct tid_ampdu_tx *tid_tx =
341				rcu_dereference_protected_tid_tx(sta, i);
342
343			if (!tid_tx)
344				continue;
345
346			if (test_and_clear_bit(HT_AGG_STATE_STOP_CB, &tid_tx->state))
347				ieee80211_stop_tx_ba_cb(sta, i, tid_tx);
348		}
349	}
 
350}
351
352void ieee80211_ba_session_work(struct wiphy *wiphy, struct wiphy_work *work)
353{
354	struct sta_info *sta =
355		container_of(work, struct sta_info, ampdu_mlme.work);
356	struct tid_ampdu_tx *tid_tx;
357	bool blocked;
358	int tid;
359
360	lockdep_assert_wiphy(sta->local->hw.wiphy);
361
362	/* When this flag is set, new sessions should be blocked. */
363	blocked = test_sta_flag(sta, WLAN_STA_BLOCK_BA);
 
 
 
 
364
 
365	for (tid = 0; tid < IEEE80211_NUM_TIDS; tid++) {
366		if (test_and_clear_bit(tid, sta->ampdu_mlme.tid_rx_timer_expired))
367			__ieee80211_stop_rx_ba_session(
368				sta, tid, WLAN_BACK_RECIPIENT,
369				WLAN_REASON_QSTA_TIMEOUT, true);
370
371		if (test_and_clear_bit(tid,
372				       sta->ampdu_mlme.tid_rx_stop_requested))
373			__ieee80211_stop_rx_ba_session(
374				sta, tid, WLAN_BACK_RECIPIENT,
375				WLAN_REASON_UNSPECIFIED, true);
376
377		if (!blocked &&
378		    test_and_clear_bit(tid,
379				       sta->ampdu_mlme.tid_rx_manage_offl))
380			__ieee80211_start_rx_ba_session(sta, 0, 0, 0, 1, tid,
381							IEEE80211_MAX_AMPDU_BUF_HT,
382							false, true, NULL);
383
384		if (test_and_clear_bit(tid + IEEE80211_NUM_TIDS,
385				       sta->ampdu_mlme.tid_rx_manage_offl))
386			__ieee80211_stop_rx_ba_session(
387				sta, tid, WLAN_BACK_RECIPIENT,
388				0, false);
389
390		spin_lock_bh(&sta->lock);
391
392		tid_tx = sta->ampdu_mlme.tid_start_tx[tid];
393		if (!blocked && tid_tx) {
394			struct txq_info *txqi = to_txq_info(sta->sta.txq[tid]);
395			struct ieee80211_sub_if_data *sdata =
396				vif_to_sdata(txqi->txq.vif);
397			struct fq *fq = &sdata->local->fq;
398
399			spin_lock_bh(&fq->lock);
400
401			/* Allow only frags to be dequeued */
402			set_bit(IEEE80211_TXQ_STOP, &txqi->flags);
403
404			if (!skb_queue_empty(&txqi->frags)) {
405				/* Fragmented Tx is ongoing, wait for it to
406				 * finish. Reschedule worker to retry later.
407				 */
408
409				spin_unlock_bh(&fq->lock);
410				spin_unlock_bh(&sta->lock);
411
412				/* Give the task working on the txq a chance
413				 * to send out the queued frags
414				 */
415				synchronize_net();
416
417				wiphy_work_queue(sdata->local->hw.wiphy, work);
418				return;
419			}
420
421			spin_unlock_bh(&fq->lock);
422
423			/*
424			 * Assign it over to the normal tid_tx array
425			 * where it "goes live".
426			 */
427
428			sta->ampdu_mlme.tid_start_tx[tid] = NULL;
429			/* could there be a race? */
430			if (sta->ampdu_mlme.tid_tx[tid])
431				kfree(tid_tx);
432			else
433				ieee80211_assign_tid_tx(sta, tid, tid_tx);
434			spin_unlock_bh(&sta->lock);
435
436			ieee80211_tx_ba_session_handle_start(sta, tid);
437			continue;
438		}
439		spin_unlock_bh(&sta->lock);
440
441		tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
442		if (!tid_tx)
443			continue;
444
445		if (!blocked &&
446		    test_and_clear_bit(HT_AGG_STATE_START_CB, &tid_tx->state))
447			ieee80211_start_tx_ba_cb(sta, tid, tid_tx);
448		if (test_and_clear_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state))
449			__ieee80211_stop_tx_ba_session(sta, tid,
450						       AGG_STOP_LOCAL_REQUEST);
451		if (test_and_clear_bit(HT_AGG_STATE_STOP_CB, &tid_tx->state))
452			ieee80211_stop_tx_ba_cb(sta, tid, tid_tx);
453	}
 
454}
455
456void ieee80211_send_delba(struct ieee80211_sub_if_data *sdata,
457			  const u8 *da, u16 tid,
458			  u16 initiator, u16 reason_code)
459{
460	struct ieee80211_local *local = sdata->local;
461	struct sk_buff *skb;
462	struct ieee80211_mgmt *mgmt;
463	u16 params;
464
465	skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
466	if (!skb)
467		return;
468
469	skb_reserve(skb, local->hw.extra_tx_headroom);
470	mgmt = skb_put_zero(skb, 24);
471	memcpy(mgmt->da, da, ETH_ALEN);
472	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
473	if (sdata->vif.type == NL80211_IFTYPE_AP ||
474	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
475	    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
476		memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
477	else if (sdata->vif.type == NL80211_IFTYPE_STATION)
478		memcpy(mgmt->bssid, sdata->deflink.u.mgd.bssid, ETH_ALEN);
479	else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
480		memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
481
482	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
483					  IEEE80211_STYPE_ACTION);
484
485	skb_put(skb, 1 + sizeof(mgmt->u.action.u.delba));
486
487	mgmt->u.action.category = WLAN_CATEGORY_BACK;
488	mgmt->u.action.u.delba.action_code = WLAN_ACTION_DELBA;
489	params = (u16)(initiator << 11); 	/* bit 11 initiator */
490	params |= (u16)(tid << 12); 		/* bit 15:12 TID number */
491
492	mgmt->u.action.u.delba.params = cpu_to_le16(params);
493	mgmt->u.action.u.delba.reason_code = cpu_to_le16(reason_code);
494
495	ieee80211_tx_skb(sdata, skb);
496}
497
498void ieee80211_process_delba(struct ieee80211_sub_if_data *sdata,
499			     struct sta_info *sta,
500			     struct ieee80211_mgmt *mgmt, size_t len)
501{
502	u16 tid, params;
503	u16 initiator;
504
505	params = le16_to_cpu(mgmt->u.action.u.delba.params);
506	tid = (params & IEEE80211_DELBA_PARAM_TID_MASK) >> 12;
507	initiator = (params & IEEE80211_DELBA_PARAM_INITIATOR_MASK) >> 11;
508
509	ht_dbg_ratelimited(sdata, "delba from %pM (%s) tid %d reason code %d\n",
510			   mgmt->sa, initiator ? "initiator" : "recipient",
511			   tid,
512			   le16_to_cpu(mgmt->u.action.u.delba.reason_code));
513
514	if (initiator == WLAN_BACK_INITIATOR)
515		__ieee80211_stop_rx_ba_session(sta, tid, WLAN_BACK_INITIATOR, 0,
516					       true);
517	else
518		__ieee80211_stop_tx_ba_session(sta, tid, AGG_STOP_PEER_REQUEST);
519}
520
521enum nl80211_smps_mode
522ieee80211_smps_mode_to_smps_mode(enum ieee80211_smps_mode smps)
523{
524	switch (smps) {
525	case IEEE80211_SMPS_OFF:
526		return NL80211_SMPS_OFF;
527	case IEEE80211_SMPS_STATIC:
528		return NL80211_SMPS_STATIC;
529	case IEEE80211_SMPS_DYNAMIC:
530		return NL80211_SMPS_DYNAMIC;
531	default:
532		return NL80211_SMPS_OFF;
533	}
534}
535
536int ieee80211_send_smps_action(struct ieee80211_sub_if_data *sdata,
537			       enum ieee80211_smps_mode smps, const u8 *da,
538			       const u8 *bssid, int link_id)
539{
540	struct ieee80211_local *local = sdata->local;
541	struct sk_buff *skb;
542	struct ieee80211_mgmt *action_frame;
543	struct ieee80211_tx_info *info;
544	u8 status_link_id = link_id < 0 ? 0 : link_id;
545
546	/* 27 = header + category + action + smps mode */
547	skb = dev_alloc_skb(27 + local->hw.extra_tx_headroom);
548	if (!skb)
549		return -ENOMEM;
550
551	skb_reserve(skb, local->hw.extra_tx_headroom);
552	action_frame = skb_put(skb, 27);
553	memcpy(action_frame->da, da, ETH_ALEN);
554	memcpy(action_frame->sa, sdata->dev->dev_addr, ETH_ALEN);
555	memcpy(action_frame->bssid, bssid, ETH_ALEN);
556	action_frame->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
557						  IEEE80211_STYPE_ACTION);
558	action_frame->u.action.category = WLAN_CATEGORY_HT;
559	action_frame->u.action.u.ht_smps.action = WLAN_HT_ACTION_SMPS;
560	switch (smps) {
561	case IEEE80211_SMPS_AUTOMATIC:
562	case IEEE80211_SMPS_NUM_MODES:
563		WARN_ON(1);
564		smps = IEEE80211_SMPS_OFF;
565		fallthrough;
566	case IEEE80211_SMPS_OFF:
567		action_frame->u.action.u.ht_smps.smps_control =
568				WLAN_HT_SMPS_CONTROL_DISABLED;
569		break;
570	case IEEE80211_SMPS_STATIC:
571		action_frame->u.action.u.ht_smps.smps_control =
572				WLAN_HT_SMPS_CONTROL_STATIC;
573		break;
574	case IEEE80211_SMPS_DYNAMIC:
575		action_frame->u.action.u.ht_smps.smps_control =
576				WLAN_HT_SMPS_CONTROL_DYNAMIC;
577		break;
578	}
579
580	/* we'll do more on status of this frame */
581	info = IEEE80211_SKB_CB(skb);
582	info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;
583	/* we have 12 bits, and need 6: link_id 4, smps 2 */
584	info->status_data = IEEE80211_STATUS_TYPE_SMPS |
585			    u16_encode_bits(status_link_id << 2 | smps,
586					    IEEE80211_STATUS_SUBDATA_MASK);
587	ieee80211_tx_skb_tid(sdata, skb, 7, link_id);
588
589	return 0;
590}
591
592void ieee80211_request_smps(struct ieee80211_vif *vif, unsigned int link_id,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
593			    enum ieee80211_smps_mode smps_mode)
594{
595	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
596	struct ieee80211_link_data *link;
597
598	if (WARN_ON_ONCE(vif->type != NL80211_IFTYPE_STATION))
 
599		return;
600
601	rcu_read_lock();
602	link = rcu_dereference(sdata->link[link_id]);
603	if (WARN_ON(!link))
604		goto out;
605
606	trace_api_request_smps(sdata->local, sdata, link, smps_mode);
607
608	if (link->u.mgd.driver_smps_mode == smps_mode)
609		goto out;
610
611	link->u.mgd.driver_smps_mode = smps_mode;
612	wiphy_work_queue(sdata->local->hw.wiphy,
613			 &link->u.mgd.request_smps_work);
614out:
615	rcu_read_unlock();
 
616}
617/* this might change ... don't want non-open drivers using it */
618EXPORT_SYMBOL_GPL(ieee80211_request_smps);