agg-tx.c

   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(c) 2015-2017 Intel Deutschland GmbH
  12 * Copyright (C) 2018 - 2024 Intel Corporation
  13 */
  14
  15#include <linux/ieee80211.h>
  16#include <linux/slab.h>
  17#include <linux/export.h>
  18#include <net/mac80211.h>
  19#include "ieee80211_i.h"
  20#include "driver-ops.h"
  21#include "wme.h"
  22
  23/**
  24 * DOC: TX A-MPDU aggregation
  25 *
  26 * Aggregation on the TX side requires setting the hardware flag
  27 * %IEEE80211_HW_AMPDU_AGGREGATION. The driver will then be handed
  28 * packets with a flag indicating A-MPDU aggregation. The driver
  29 * or device is responsible for actually aggregating the frames,
  30 * as well as deciding how many and which to aggregate.
  31 *
  32 * When TX aggregation is started by some subsystem (usually the rate
  33 * control algorithm would be appropriate) by calling the
  34 * ieee80211_start_tx_ba_session() function, the driver will be
  35 * notified via its @ampdu_action function, with the
  36 * %IEEE80211_AMPDU_TX_START action.
  37 *
  38 * In response to that, the driver is later required to call the
  39 * ieee80211_start_tx_ba_cb_irqsafe() function, which will really
  40 * start the aggregation session after the peer has also responded.
  41 * If the peer responds negatively, the session will be stopped
  42 * again right away. Note that it is possible for the aggregation
  43 * session to be stopped before the driver has indicated that it
  44 * is done setting it up, in which case it must not indicate the
  45 * setup completion.
  46 *
  47 * Also note that, since we also need to wait for a response from
  48 * the peer, the driver is notified of the completion of the
  49 * handshake by the %IEEE80211_AMPDU_TX_OPERATIONAL action to the
  50 * @ampdu_action callback.
  51 *
  52 * Similarly, when the aggregation session is stopped by the peer
  53 * or something calling ieee80211_stop_tx_ba_session(), the driver's
  54 * @ampdu_action function will be called with the action
  55 * %IEEE80211_AMPDU_TX_STOP. In this case, the call must not fail,
  56 * and the driver must later call ieee80211_stop_tx_ba_cb_irqsafe().
  57 * Note that the sta can get destroyed before the BA tear down is
  58 * complete.
  59 */
  60
  61static void ieee80211_send_addba_request(struct sta_info *sta, u16 tid,
  62					 u8 dialog_token, u16 start_seq_num,
  63					 u16 agg_size, u16 timeout)
  64{
  65	struct ieee80211_sub_if_data *sdata = sta->sdata;
  66	struct ieee80211_local *local = sdata->local;
  67	struct sk_buff *skb;
  68	struct ieee80211_mgmt *mgmt;
  69	u16 capab;
  70
  71	skb = dev_alloc_skb(sizeof(*mgmt) +
  72			    2 + sizeof(struct ieee80211_addba_ext_ie) +
  73			    local->hw.extra_tx_headroom);
  74	if (!skb)
  75		return;
  76
  77	skb_reserve(skb, local->hw.extra_tx_headroom);
  78	mgmt = ieee80211_mgmt_ba(skb, sta->sta.addr, sdata);
  79
  80	skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_req));
  81
  82	mgmt->u.action.category = WLAN_CATEGORY_BACK;
  83	mgmt->u.action.u.addba_req.action_code = WLAN_ACTION_ADDBA_REQ;
  84
  85	mgmt->u.action.u.addba_req.dialog_token = dialog_token;
  86	capab = IEEE80211_ADDBA_PARAM_AMSDU_MASK;
  87	capab |= IEEE80211_ADDBA_PARAM_POLICY_MASK;
  88	capab |= u16_encode_bits(tid, IEEE80211_ADDBA_PARAM_TID_MASK);
  89	capab |= u16_encode_bits(agg_size, IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK);
  90
  91	mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);
  92
  93	mgmt->u.action.u.addba_req.timeout = cpu_to_le16(timeout);
  94	mgmt->u.action.u.addba_req.start_seq_num =
  95					cpu_to_le16(start_seq_num << 4);
  96
  97	if (sta->sta.deflink.he_cap.has_he)
  98		ieee80211_add_addbaext(skb, 0, agg_size);
  99
 100	ieee80211_tx_skb_tid(sdata, skb, tid, -1);
 101}
 102
 103void ieee80211_send_bar(struct ieee80211_vif *vif, u8 *ra, u16 tid, u16 ssn)
 104{
 105	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 106	struct ieee80211_local *local = sdata->local;
 107	struct sk_buff *skb;
 108	struct ieee80211_bar *bar;
 109	u16 bar_control = 0;
 110
 111	skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom);
 112	if (!skb)
 113		return;
 114
 115	skb_reserve(skb, local->hw.extra_tx_headroom);
 116	bar = skb_put_zero(skb, sizeof(*bar));
 117	bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
 118					 IEEE80211_STYPE_BACK_REQ);
 119	memcpy(bar->ra, ra, ETH_ALEN);
 120	memcpy(bar->ta, sdata->vif.addr, ETH_ALEN);
 121	bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL;
 122	bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA;
 123	bar_control |= (u16)(tid << IEEE80211_BAR_CTRL_TID_INFO_SHIFT);
 124	bar->control = cpu_to_le16(bar_control);
 125	bar->start_seq_num = cpu_to_le16(ssn);
 126
 127	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
 128					IEEE80211_TX_CTL_REQ_TX_STATUS;
 129	ieee80211_tx_skb_tid(sdata, skb, tid, -1);
 130}
 131EXPORT_SYMBOL(ieee80211_send_bar);
 132
 133void ieee80211_assign_tid_tx(struct sta_info *sta, int tid,
 134			     struct tid_ampdu_tx *tid_tx)
 135{
 136	lockdep_assert_wiphy(sta->local->hw.wiphy);
 137	lockdep_assert_held(&sta->lock);
 138	rcu_assign_pointer(sta->ampdu_mlme.tid_tx[tid], tid_tx);
 139}
 140
 141/*
 142 * When multiple aggregation sessions on multiple stations
 143 * are being created/destroyed simultaneously, we need to
 144 * refcount the global queue stop caused by that in order
 145 * to not get into a situation where one of the aggregation
 146 * setup or teardown re-enables queues before the other is
 147 * ready to handle that.
 148 *
 149 * These two functions take care of this issue by keeping
 150 * a global "agg_queue_stop" refcount.
 151 */
 152static void __acquires(agg_queue)
 153ieee80211_stop_queue_agg(struct ieee80211_sub_if_data *sdata, int tid)
 154{
 155	int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
 156
 157	/* we do refcounting here, so don't use the queue reason refcounting */
 158
 159	if (atomic_inc_return(&sdata->local->agg_queue_stop[queue]) == 1)
 160		ieee80211_stop_queue_by_reason(
 161			&sdata->local->hw, queue,
 162			IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
 163			false);
 164	__acquire(agg_queue);
 165}
 166
 167static void __releases(agg_queue)
 168ieee80211_wake_queue_agg(struct ieee80211_sub_if_data *sdata, int tid)
 169{
 170	int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
 171
 172	if (atomic_dec_return(&sdata->local->agg_queue_stop[queue]) == 0)
 173		ieee80211_wake_queue_by_reason(
 174			&sdata->local->hw, queue,
 175			IEEE80211_QUEUE_STOP_REASON_AGGREGATION,
 176			false);
 177	__release(agg_queue);
 178}
 179
 180static void
 181ieee80211_agg_stop_txq(struct sta_info *sta, int tid)
 182{
 183	struct ieee80211_txq *txq = sta->sta.txq[tid];
 184	struct ieee80211_sub_if_data *sdata;
 185	struct fq *fq;
 186	struct txq_info *txqi;
 187
 188	if (!txq)
 189		return;
 190
 191	txqi = to_txq_info(txq);
 192	sdata = vif_to_sdata(txq->vif);
 193	fq = &sdata->local->fq;
 194
 195	/* Lock here to protect against further seqno updates on dequeue */
 196	spin_lock_bh(&fq->lock);
 197	set_bit(IEEE80211_TXQ_STOP, &txqi->flags);
 198	spin_unlock_bh(&fq->lock);
 199}
 200
 201static void
 202ieee80211_agg_start_txq(struct sta_info *sta, int tid, bool enable)
 203{
 204	struct ieee80211_txq *txq = sta->sta.txq[tid];
 205	struct txq_info *txqi;
 206
 207	lockdep_assert_wiphy(sta->local->hw.wiphy);
 208
 209	if (!txq)
 210		return;
 211
 212	txqi = to_txq_info(txq);
 213
 214	if (enable)
 215		set_bit(IEEE80211_TXQ_AMPDU, &txqi->flags);
 216	else
 217		clear_bit(IEEE80211_TXQ_AMPDU, &txqi->flags);
 218
 219	clear_bit(IEEE80211_TXQ_STOP, &txqi->flags);
 220	local_bh_disable();
 221	rcu_read_lock();
 222	schedule_and_wake_txq(sta->sdata->local, txqi);
 223	rcu_read_unlock();
 224	local_bh_enable();
 225}
 226
 227/*
 228 * splice packets from the STA's pending to the local pending,
 229 * requires a call to ieee80211_agg_splice_finish later
 230 */
 231static void __acquires(agg_queue)
 232ieee80211_agg_splice_packets(struct ieee80211_sub_if_data *sdata,
 233			     struct tid_ampdu_tx *tid_tx, u16 tid)
 234{
 235	struct ieee80211_local *local = sdata->local;
 236	int queue = sdata->vif.hw_queue[ieee80211_ac_from_tid(tid)];
 237	unsigned long flags;
 238
 239	ieee80211_stop_queue_agg(sdata, tid);
 240
 241	if (WARN(!tid_tx,
 242		 "TID %d gone but expected when splicing aggregates from the pending queue\n",
 243		 tid))
 244		return;
 245
 246	if (!skb_queue_empty(&tid_tx->pending)) {
 247		spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 248		/* copy over remaining packets */
 249		skb_queue_splice_tail_init(&tid_tx->pending,
 250					   &local->pending[queue]);
 251		spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 252	}
 253}
 254
 255static void __releases(agg_queue)
 256ieee80211_agg_splice_finish(struct ieee80211_sub_if_data *sdata, u16 tid)
 257{
 258	ieee80211_wake_queue_agg(sdata, tid);
 259}
 260
 261static void ieee80211_remove_tid_tx(struct sta_info *sta, int tid)
 262{
 263	struct tid_ampdu_tx *tid_tx;
 264
 265	lockdep_assert_wiphy(sta->local->hw.wiphy);
 266	lockdep_assert_held(&sta->lock);
 267
 268	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 269
 270	/*
 271	 * When we get here, the TX path will not be lockless any more wrt.
 272	 * aggregation, since the OPERATIONAL bit has long been cleared.
 273	 * Thus it will block on getting the lock, if it occurs. So if we
 274	 * stop the queue now, we will not get any more packets, and any
 275	 * that might be being processed will wait for us here, thereby
 276	 * guaranteeing that no packets go to the tid_tx pending queue any
 277	 * more.
 278	 */
 279
 280	ieee80211_agg_splice_packets(sta->sdata, tid_tx, tid);
 281
 282	/* future packets must not find the tid_tx struct any more */
 283	ieee80211_assign_tid_tx(sta, tid, NULL);
 284
 285	ieee80211_agg_splice_finish(sta->sdata, tid);
 286
 287	kfree_rcu(tid_tx, rcu_head);
 288}
 289
 290int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 291				   enum ieee80211_agg_stop_reason reason)
 292{
 293	struct ieee80211_local *local = sta->local;
 294	struct tid_ampdu_tx *tid_tx;
 295	struct ieee80211_ampdu_params params = {
 296		.sta = &sta->sta,
 297		.tid = tid,
 298		.buf_size = 0,
 299		.amsdu = false,
 300		.timeout = 0,
 301		.ssn = 0,
 302	};
 303	int ret;
 304
 305	lockdep_assert_wiphy(sta->local->hw.wiphy);
 306
 307	switch (reason) {
 308	case AGG_STOP_DECLINED:
 309	case AGG_STOP_LOCAL_REQUEST:
 310	case AGG_STOP_PEER_REQUEST:
 311		params.action = IEEE80211_AMPDU_TX_STOP_CONT;
 312		break;
 313	case AGG_STOP_DESTROY_STA:
 314		params.action = IEEE80211_AMPDU_TX_STOP_FLUSH;
 315		break;
 316	default:
 317		WARN_ON_ONCE(1);
 318		return -EINVAL;
 319	}
 320
 321	spin_lock_bh(&sta->lock);
 322
 323	/* free struct pending for start, if present */
 324	tid_tx = sta->ampdu_mlme.tid_start_tx[tid];
 325	kfree(tid_tx);
 326	sta->ampdu_mlme.tid_start_tx[tid] = NULL;
 327
 328	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 329	if (!tid_tx) {
 330		spin_unlock_bh(&sta->lock);
 331		return -ENOENT;
 332	}
 333
 334	/*
 335	 * if we're already stopping ignore any new requests to stop
 336	 * unless we're destroying it in which case notify the driver
 337	 */
 338	if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 339		spin_unlock_bh(&sta->lock);
 340		if (reason != AGG_STOP_DESTROY_STA)
 341			return -EALREADY;
 342		params.action = IEEE80211_AMPDU_TX_STOP_FLUSH_CONT;
 343		ret = drv_ampdu_action(local, sta->sdata, &params);
 344		WARN_ON_ONCE(ret);
 345		return 0;
 346	}
 347
 348	if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
 349		/* not even started yet! */
 350		ieee80211_assign_tid_tx(sta, tid, NULL);
 351		spin_unlock_bh(&sta->lock);
 352		kfree_rcu(tid_tx, rcu_head);
 353		return 0;
 354	}
 355
 356	set_bit(HT_AGG_STATE_STOPPING, &tid_tx->state);
 357
 358	ieee80211_agg_stop_txq(sta, tid);
 359
 360	spin_unlock_bh(&sta->lock);
 361
 362	ht_dbg(sta->sdata, "Tx BA session stop requested for %pM tid %u\n",
 363	       sta->sta.addr, tid);
 364
 365	timer_delete_sync(&tid_tx->addba_resp_timer);
 366	timer_delete_sync(&tid_tx->session_timer);
 367
 368	/*
 369	 * After this packets are no longer handed right through
 370	 * to the driver but are put onto tid_tx->pending instead,
 371	 * with locking to ensure proper access.
 372	 */
 373	clear_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
 374
 375	/*
 376	 * There might be a few packets being processed right now (on
 377	 * another CPU) that have already gotten past the aggregation
 378	 * check when it was still OPERATIONAL and consequently have
 379	 * IEEE80211_TX_CTL_AMPDU set. In that case, this code might
 380	 * call into the driver at the same time or even before the
 381	 * TX paths calls into it, which could confuse the driver.
 382	 *
 383	 * Wait for all currently running TX paths to finish before
 384	 * telling the driver. New packets will not go through since
 385	 * the aggregation session is no longer OPERATIONAL.
 386	 */
 387	if (!local->in_reconfig)
 388		synchronize_net();
 389
 390	tid_tx->stop_initiator = reason == AGG_STOP_PEER_REQUEST ?
 391					WLAN_BACK_RECIPIENT :
 392					WLAN_BACK_INITIATOR;
 393	tid_tx->tx_stop = reason == AGG_STOP_LOCAL_REQUEST;
 394
 395	ret = drv_ampdu_action(local, sta->sdata, &params);
 396
 397	/* HW shall not deny going back to legacy */
 398	if (WARN_ON(ret)) {
 399		/*
 400		 * We may have pending packets get stuck in this case...
 401		 * Not bothering with a workaround for now.
 402		 */
 403	}
 404
 405	/*
 406	 * In the case of AGG_STOP_DESTROY_STA, the driver won't
 407	 * necessarily call ieee80211_stop_tx_ba_cb(), so this may
 408	 * seem like we can leave the tid_tx data pending forever.
 409	 * This is true, in a way, but "forever" is only until the
 410	 * station struct is actually destroyed. In the meantime,
 411	 * leaving it around ensures that we don't transmit packets
 412	 * to the driver on this TID which might confuse it.
 413	 */
 414
 415	return 0;
 416}
 417
 418/*
 419 * After sending add Block Ack request we activated a timer until
 420 * add Block Ack response will arrive from the recipient.
 421 * If this timer expires sta_addba_resp_timer_expired will be executed.
 422 */
 423static void sta_addba_resp_timer_expired(struct timer_list *t)
 424{
 425	struct tid_ampdu_tx *tid_tx = timer_container_of(tid_tx, t,
 426							 addba_resp_timer);
 427	struct sta_info *sta = tid_tx->sta;
 428	u8 tid = tid_tx->tid;
 429
 430	/* check if the TID waits for addBA response */
 431	if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state)) {
 432		ht_dbg(sta->sdata,
 433		       "timer expired on %pM tid %d not expecting addBA response\n",
 434		       sta->sta.addr, tid);
 435		return;
 436	}
 437
 438	ht_dbg(sta->sdata, "addBA response timer expired on %pM tid %d\n",
 439	       sta->sta.addr, tid);
 440
 441	ieee80211_stop_tx_ba_session(&sta->sta, tid);
 442}
 443
 444static void ieee80211_send_addba_with_timeout(struct sta_info *sta,
 445					      struct tid_ampdu_tx *tid_tx)
 446{
 447	struct ieee80211_sub_if_data *sdata = sta->sdata;
 448	struct ieee80211_local *local = sta->local;
 449	u8 tid = tid_tx->tid;
 450	u16 buf_size;
 451
 452	if (WARN_ON_ONCE(test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state) ||
 453			 test_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state)))
 454		return;
 455
 456	lockdep_assert_wiphy(sta->local->hw.wiphy);
 457
 458	/* activate the timer for the recipient's addBA response */
 459	mod_timer(&tid_tx->addba_resp_timer, jiffies + ADDBA_RESP_INTERVAL);
 460	ht_dbg(sdata, "activated addBA response timer on %pM tid %d\n",
 461	       sta->sta.addr, tid);
 462
 463	spin_lock_bh(&sta->lock);
 464	sta->ampdu_mlme.last_addba_req_time[tid] = jiffies;
 465	sta->ampdu_mlme.addba_req_num[tid]++;
 466	spin_unlock_bh(&sta->lock);
 467
 468	if (sta->sta.valid_links ||
 469	    sta->sta.deflink.eht_cap.has_eht ||
 470	    ieee80211_hw_check(&local->hw, STRICT)) {
 471		buf_size = local->hw.max_tx_aggregation_subframes;
 472	} else if (sta->sta.deflink.he_cap.has_he) {
 473		buf_size = min_t(u16, local->hw.max_tx_aggregation_subframes,
 474				 IEEE80211_MAX_AMPDU_BUF_HE);
 475	} else {
 476		/*
 477		 * We really should use what the driver told us it will
 478		 * transmit as the maximum, but certain APs (e.g. the
 479		 * LinkSys WRT120N with FW v1.0.07 build 002 Jun 18 2012)
 480		 * will crash when we use a lower number.
 481		 */
 482		buf_size = IEEE80211_MAX_AMPDU_BUF_HT;
 483	}
 484
 485	/* send AddBA request */
 486	ieee80211_send_addba_request(sta, tid, tid_tx->dialog_token,
 487				     tid_tx->ssn, buf_size, tid_tx->timeout);
 488
 489	WARN_ON(test_and_set_bit(HT_AGG_STATE_SENT_ADDBA, &tid_tx->state));
 490}
 491
 492void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid)
 493{
 494	struct tid_ampdu_tx *tid_tx;
 495	struct ieee80211_local *local = sta->local;
 496	struct ieee80211_sub_if_data *sdata = sta->sdata;
 497	struct ieee80211_ampdu_params params = {
 498		.sta = &sta->sta,
 499		.action = IEEE80211_AMPDU_TX_START,
 500		.tid = tid,
 501		.buf_size = 0,
 502		.amsdu = false,
 503		.timeout = 0,
 504	};
 505	int ret;
 506
 507	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 508
 509	/*
 510	 * Start queuing up packets for this aggregation session.
 511	 * We're going to release them once the driver is OK with
 512	 * that.
 513	 */
 514	clear_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
 515
 516	/*
 517	 * Make sure no packets are being processed. This ensures that
 518	 * we have a valid starting sequence number and that in-flight
 519	 * packets have been flushed out and no packets for this TID
 520	 * will go into the driver during the ampdu_action call.
 521	 */
 522	synchronize_net();
 523
 524	params.ssn = sta->tid_seq[tid] >> 4;
 525	ret = drv_ampdu_action(local, sdata, &params);
 526	tid_tx->ssn = params.ssn;
 527	if (ret == IEEE80211_AMPDU_TX_START_DELAY_ADDBA) {
 528		return;
 529	} else if (ret == IEEE80211_AMPDU_TX_START_IMMEDIATE) {
 530		/*
 531		 * We didn't send the request yet, so don't need to check
 532		 * here if we already got a response, just mark as driver
 533		 * ready immediately.
 534		 */
 535		set_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state);
 536	} else if (ret) {
 537		ht_dbg(sdata,
 538		       "BA request denied - HW unavailable for %pM tid %d\n",
 539		       sta->sta.addr, tid);
 540		spin_lock_bh(&sta->lock);
 541		ieee80211_agg_splice_packets(sdata, tid_tx, tid);
 542		ieee80211_assign_tid_tx(sta, tid, NULL);
 543		ieee80211_agg_splice_finish(sdata, tid);
 544		spin_unlock_bh(&sta->lock);
 545
 546		ieee80211_agg_start_txq(sta, tid, false);
 547
 548		kfree_rcu(tid_tx, rcu_head);
 549		return;
 550	}
 551
 552	ieee80211_send_addba_with_timeout(sta, tid_tx);
 553}
 554
 555void ieee80211_refresh_tx_agg_session_timer(struct ieee80211_sta *pubsta,
 556					    u16 tid)
 557{
 558	struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
 559	struct tid_ampdu_tx *tid_tx;
 560
 561	if (WARN_ON_ONCE(tid >= IEEE80211_NUM_TIDS))
 562		return;
 563
 564	tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
 565	if (!tid_tx)
 566		return;
 567
 568	tid_tx->last_tx = jiffies;
 569}
 570EXPORT_SYMBOL(ieee80211_refresh_tx_agg_session_timer);
 571
 572/*
 573 * After accepting the AddBA Response we activated a timer,
 574 * resetting it after each frame that we send.
 575 */
 576static void sta_tx_agg_session_timer_expired(struct timer_list *t)
 577{
 578	struct tid_ampdu_tx *tid_tx = timer_container_of(tid_tx, t,
 579							 session_timer);
 580	struct sta_info *sta = tid_tx->sta;
 581	u8 tid = tid_tx->tid;
 582	unsigned long timeout;
 583
 584	if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 585		return;
 586	}
 587
 588	timeout = tid_tx->last_tx + TU_TO_JIFFIES(tid_tx->timeout);
 589	if (time_is_after_jiffies(timeout)) {
 590		mod_timer(&tid_tx->session_timer, timeout);
 591		return;
 592	}
 593
 594	ht_dbg(sta->sdata, "tx session timer expired on %pM tid %d\n",
 595	       sta->sta.addr, tid);
 596
 597	ieee80211_stop_tx_ba_session(&sta->sta, tid);
 598}
 599
 600int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,
 601				  u16 timeout)
 602{
 603	struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
 604	struct ieee80211_sub_if_data *sdata = sta->sdata;
 605	struct ieee80211_local *local = sdata->local;
 606	struct tid_ampdu_tx *tid_tx;
 607	int ret = 0;
 608
 609	trace_api_start_tx_ba_session(pubsta, tid);
 610
 611	if (WARN(sta->reserved_tid == tid,
 612		 "Requested to start BA session on reserved tid=%d", tid))
 613		return -EINVAL;
 614
 615	if (!pubsta->valid_links &&
 616	    !pubsta->deflink.ht_cap.ht_supported &&
 617	    !pubsta->deflink.vht_cap.vht_supported &&
 618	    !pubsta->deflink.he_cap.has_he &&
 619	    !pubsta->deflink.eht_cap.has_eht &&
 620	    !pubsta->deflink.s1g_cap.s1g)
 621		return -EINVAL;
 622
 623	if (WARN_ON_ONCE(!local->ops->ampdu_action))
 624		return -EINVAL;
 625
 626	if ((tid >= IEEE80211_NUM_TIDS) ||
 627	    !ieee80211_hw_check(&local->hw, AMPDU_AGGREGATION) ||
 628	    ieee80211_hw_check(&local->hw, TX_AMPDU_SETUP_IN_HW))
 629		return -EINVAL;
 630
 631	if (WARN_ON(tid >= IEEE80211_FIRST_TSPEC_TSID))
 632		return -EINVAL;
 633
 634	ht_dbg(sdata, "Open BA session requested for %pM tid %u\n",
 635	       pubsta->addr, tid);
 636
 637	if (sdata->vif.type != NL80211_IFTYPE_STATION &&
 638	    sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
 639	    sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
 640	    sdata->vif.type != NL80211_IFTYPE_AP &&
 641	    sdata->vif.type != NL80211_IFTYPE_ADHOC)
 642		return -EINVAL;
 643
 644	if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) {
 645		ht_dbg(sdata,
 646		       "BA sessions blocked - Denying BA session request %pM tid %d\n",
 647		       sta->sta.addr, tid);
 648		return -EINVAL;
 649	}
 650
 651	if (test_sta_flag(sta, WLAN_STA_MFP) &&
 652	    !test_sta_flag(sta, WLAN_STA_AUTHORIZED)) {
 653		ht_dbg(sdata,
 654		       "MFP STA not authorized - deny BA session request %pM tid %d\n",
 655		       sta->sta.addr, tid);
 656		return -EINVAL;
 657	}
 658
 659	/*
 660	 * 802.11n-2009 11.5.1.1: If the initiating STA is an HT STA, is a
 661	 * member of an IBSS, and has no other existing Block Ack agreement
 662	 * with the recipient STA, then the initiating STA shall transmit a
 663	 * Probe Request frame to the recipient STA and shall not transmit an
 664	 * ADDBA Request frame unless it receives a Probe Response frame
 665	 * from the recipient within dot11ADDBAFailureTimeout.
 666	 *
 667	 * The probe request mechanism for ADDBA is currently not implemented,
 668	 * but we only build up Block Ack session with HT STAs. This information
 669	 * is set when we receive a bss info from a probe response or a beacon.
 670	 */
 671	if (sta->sdata->vif.type == NL80211_IFTYPE_ADHOC &&
 672	    !sta->sta.deflink.ht_cap.ht_supported) {
 673		ht_dbg(sdata,
 674		       "BA request denied - IBSS STA %pM does not advertise HT support\n",
 675		       pubsta->addr);
 676		return -EINVAL;
 677	}
 678
 679	spin_lock_bh(&sta->lock);
 680
 681	/* we have tried too many times, receiver does not want A-MPDU */
 682	if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) {
 683		ret = -EBUSY;
 684		goto err_unlock_sta;
 685	}
 686
 687	/*
 688	 * if we have tried more than HT_AGG_BURST_RETRIES times we
 689	 * will spread our requests in time to avoid stalling connection
 690	 * for too long
 691	 */
 692	if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_BURST_RETRIES &&
 693	    time_before(jiffies, sta->ampdu_mlme.last_addba_req_time[tid] +
 694			HT_AGG_RETRIES_PERIOD)) {
 695		ht_dbg(sdata,
 696		       "BA request denied - %d failed requests on %pM tid %u\n",
 697		       sta->ampdu_mlme.addba_req_num[tid], sta->sta.addr, tid);
 698		ret = -EBUSY;
 699		goto err_unlock_sta;
 700	}
 701
 702	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 703	/* check if the TID is not in aggregation flow already */
 704	if (tid_tx || sta->ampdu_mlme.tid_start_tx[tid]) {
 705		ht_dbg(sdata,
 706		       "BA request denied - session is not idle on %pM tid %u\n",
 707		       sta->sta.addr, tid);
 708		ret = -EAGAIN;
 709		goto err_unlock_sta;
 710	}
 711
 712	/* prepare A-MPDU MLME for Tx aggregation */
 713	tid_tx = kzalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
 714	if (!tid_tx) {
 715		ret = -ENOMEM;
 716		goto err_unlock_sta;
 717	}
 718
 719	skb_queue_head_init(&tid_tx->pending);
 720	__set_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
 721
 722	tid_tx->timeout = timeout;
 723	tid_tx->sta = sta;
 724	tid_tx->tid = tid;
 725
 726	/* response timer */
 727	timer_setup(&tid_tx->addba_resp_timer, sta_addba_resp_timer_expired, 0);
 728
 729	/* tx timer */
 730	timer_setup(&tid_tx->session_timer,
 731		    sta_tx_agg_session_timer_expired, TIMER_DEFERRABLE);
 732
 733	/* assign a dialog token */
 734	sta->ampdu_mlme.dialog_token_allocator++;
 735	tid_tx->dialog_token = sta->ampdu_mlme.dialog_token_allocator;
 736
 737	/*
 738	 * Finally, assign it to the start array; the work item will
 739	 * collect it and move it to the normal array.
 740	 */
 741	sta->ampdu_mlme.tid_start_tx[tid] = tid_tx;
 742
 743	wiphy_work_queue(local->hw.wiphy, &sta->ampdu_mlme.work);
 744
 745	/* this flow continues off the work */
 746 err_unlock_sta:
 747	spin_unlock_bh(&sta->lock);
 748	return ret;
 749}
 750EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
 751
 752static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
 753					 struct sta_info *sta, u16 tid)
 754{
 755	struct tid_ampdu_tx *tid_tx;
 756	struct ieee80211_ampdu_params params = {
 757		.sta = &sta->sta,
 758		.action = IEEE80211_AMPDU_TX_OPERATIONAL,
 759		.tid = tid,
 760		.timeout = 0,
 761		.ssn = 0,
 762	};
 763
 764	lockdep_assert_wiphy(sta->local->hw.wiphy);
 765
 766	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 767	params.buf_size = tid_tx->buf_size;
 768	params.amsdu = tid_tx->amsdu;
 769
 770	ht_dbg(sta->sdata, "Aggregation is on for %pM tid %d\n",
 771	       sta->sta.addr, tid);
 772
 773	drv_ampdu_action(local, sta->sdata, &params);
 774
 775	/*
 776	 * synchronize with TX path, while splicing the TX path
 777	 * should block so it won't put more packets onto pending.
 778	 */
 779	spin_lock_bh(&sta->lock);
 780
 781	ieee80211_agg_splice_packets(sta->sdata, tid_tx, tid);
 782	/*
 783	 * Now mark as operational. This will be visible
 784	 * in the TX path, and lets it go lock-free in
 785	 * the common case.
 786	 */
 787	set_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
 788	ieee80211_agg_splice_finish(sta->sdata, tid);
 789
 790	spin_unlock_bh(&sta->lock);
 791
 792	ieee80211_agg_start_txq(sta, tid, true);
 793}
 794
 795void ieee80211_start_tx_ba_cb(struct sta_info *sta, int tid,
 796			      struct tid_ampdu_tx *tid_tx)
 797{
 798	struct ieee80211_sub_if_data *sdata = sta->sdata;
 799	struct ieee80211_local *local = sdata->local;
 800
 801	lockdep_assert_wiphy(sta->local->hw.wiphy);
 802
 803	if (WARN_ON(test_and_set_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state)))
 804		return;
 805
 806	if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state) ||
 807	    test_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state))
 808		return;
 809
 810	if (!test_bit(HT_AGG_STATE_SENT_ADDBA, &tid_tx->state)) {
 811		ieee80211_send_addba_with_timeout(sta, tid_tx);
 812		/* RESPONSE_RECEIVED state would trigger the flow again */
 813		return;
 814	}
 815
 816	if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state))
 817		ieee80211_agg_tx_operational(local, sta, tid);
 818}
 819
 820static struct tid_ampdu_tx *
 821ieee80211_lookup_tid_tx(struct ieee80211_sub_if_data *sdata,
 822			const u8 *ra, u16 tid, struct sta_info **sta)
 823{
 824	struct tid_ampdu_tx *tid_tx;
 825
 826	if (tid >= IEEE80211_NUM_TIDS) {
 827		ht_dbg(sdata, "Bad TID value: tid = %d (>= %d)\n",
 828		       tid, IEEE80211_NUM_TIDS);
 829		return NULL;
 830	}
 831
 832	*sta = sta_info_get_bss(sdata, ra);
 833	if (!*sta) {
 834		ht_dbg(sdata, "Could not find station: %pM\n", ra);
 835		return NULL;
 836	}
 837
 838	tid_tx = rcu_dereference((*sta)->ampdu_mlme.tid_tx[tid]);
 839
 840	if (WARN_ON(!tid_tx))
 841		ht_dbg(sdata, "addBA was not requested!\n");
 842
 843	return tid_tx;
 844}
 845
 846void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
 847				      const u8 *ra, u16 tid)
 848{
 849	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 850	struct ieee80211_local *local = sdata->local;
 851	struct sta_info *sta;
 852	struct tid_ampdu_tx *tid_tx;
 853
 854	trace_api_start_tx_ba_cb(sdata, ra, tid);
 855
 856	rcu_read_lock();
 857	tid_tx = ieee80211_lookup_tid_tx(sdata, ra, tid, &sta);
 858	if (!tid_tx)
 859		goto out;
 860
 861	set_bit(HT_AGG_STATE_START_CB, &tid_tx->state);
 862	wiphy_work_queue(local->hw.wiphy, &sta->ampdu_mlme.work);
 863 out:
 864	rcu_read_unlock();
 865}
 866EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe);
 867
 868int ieee80211_stop_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid)
 869{
 870	struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
 871	struct ieee80211_sub_if_data *sdata = sta->sdata;
 872	struct ieee80211_local *local = sdata->local;
 873	struct tid_ampdu_tx *tid_tx;
 874	int ret = 0;
 875
 876	trace_api_stop_tx_ba_session(pubsta, tid);
 877
 878	if (!local->ops->ampdu_action)
 879		return -EINVAL;
 880
 881	if (tid >= IEEE80211_NUM_TIDS)
 882		return -EINVAL;
 883
 884	spin_lock_bh(&sta->lock);
 885	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 886
 887	if (!tid_tx) {
 888		ret = -ENOENT;
 889		goto unlock;
 890	}
 891
 892	WARN(sta->reserved_tid == tid,
 893	     "Requested to stop BA session on reserved tid=%d", tid);
 894
 895	if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 896		/* already in progress stopping it */
 897		ret = 0;
 898		goto unlock;
 899	}
 900
 901	set_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state);
 902	wiphy_work_queue(local->hw.wiphy, &sta->ampdu_mlme.work);
 903
 904 unlock:
 905	spin_unlock_bh(&sta->lock);
 906	return ret;
 907}
 908EXPORT_SYMBOL(ieee80211_stop_tx_ba_session);
 909
 910void ieee80211_stop_tx_ba_cb(struct sta_info *sta, int tid,
 911			     struct tid_ampdu_tx *tid_tx)
 912{
 913	struct ieee80211_sub_if_data *sdata = sta->sdata;
 914	bool send_delba = false;
 915	bool start_txq = false;
 916
 917	ht_dbg(sdata, "Stopping Tx BA session for %pM tid %d\n",
 918	       sta->sta.addr, tid);
 919
 920	spin_lock_bh(&sta->lock);
 921
 922	if (!test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 923		ht_dbg(sdata,
 924		       "unexpected callback to A-MPDU stop for %pM tid %d\n",
 925		       sta->sta.addr, tid);
 926		goto unlock_sta;
 927	}
 928
 929	if (tid_tx->stop_initiator == WLAN_BACK_INITIATOR && tid_tx->tx_stop)
 930		send_delba = true;
 931
 932	ieee80211_remove_tid_tx(sta, tid);
 933	start_txq = true;
 934
 935 unlock_sta:
 936	spin_unlock_bh(&sta->lock);
 937
 938	if (start_txq)
 939		ieee80211_agg_start_txq(sta, tid, false);
 940
 941	if (send_delba)
 942		ieee80211_send_delba(sdata, sta->sta.addr, tid,
 943			WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
 944}
 945
 946void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
 947				     const u8 *ra, u16 tid)
 948{
 949	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 950	struct ieee80211_local *local = sdata->local;
 951	struct sta_info *sta;
 952	struct tid_ampdu_tx *tid_tx;
 953
 954	trace_api_stop_tx_ba_cb(sdata, ra, tid);
 955
 956	rcu_read_lock();
 957	tid_tx = ieee80211_lookup_tid_tx(sdata, ra, tid, &sta);
 958	if (!tid_tx)
 959		goto out;
 960
 961	set_bit(HT_AGG_STATE_STOP_CB, &tid_tx->state);
 962	wiphy_work_queue(local->hw.wiphy, &sta->ampdu_mlme.work);
 963 out:
 964	rcu_read_unlock();
 965}
 966EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe);
 967
 968
 969void ieee80211_process_addba_resp(struct ieee80211_local *local,
 970				  struct sta_info *sta,
 971				  struct ieee80211_mgmt *mgmt,
 972				  size_t len)
 973{
 974	struct tid_ampdu_tx *tid_tx;
 975	struct ieee80211_txq *txq;
 976	u16 capab, tid, buf_size;
 977	bool amsdu;
 978
 979	lockdep_assert_wiphy(sta->local->hw.wiphy);
 980
 981	capab = le16_to_cpu(mgmt->u.action.u.addba_resp.capab);
 982	amsdu = capab & IEEE80211_ADDBA_PARAM_AMSDU_MASK;
 983	tid = u16_get_bits(capab, IEEE80211_ADDBA_PARAM_TID_MASK);
 984	buf_size = u16_get_bits(capab, IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK);
 985
 986	ieee80211_retrieve_addba_ext_data(sta,
 987					  mgmt->u.action.u.addba_resp.variable,
 988					  len - offsetof(typeof(*mgmt),
 989							 u.action.u.addba_resp.variable),
 990					  &buf_size);
 991
 992	buf_size = min(buf_size, local->hw.max_tx_aggregation_subframes);
 993
 994	txq = sta->sta.txq[tid];
 995	if (!amsdu && txq)
 996		set_bit(IEEE80211_TXQ_NO_AMSDU, &to_txq_info(txq)->flags);
 997
 998	tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 999	if (!tid_tx)
1000		return;
1001
1002	if (mgmt->u.action.u.addba_resp.dialog_token != tid_tx->dialog_token) {
1003		ht_dbg(sta->sdata, "wrong addBA response token, %pM tid %d\n",
1004		       sta->sta.addr, tid);
1005		return;
1006	}
1007
1008	timer_delete_sync(&tid_tx->addba_resp_timer);
1009
1010	ht_dbg(sta->sdata, "switched off addBA timer for %pM tid %d\n",
1011	       sta->sta.addr, tid);
1012
1013	/*
1014	 * addba_resp_timer may have fired before we got here, and
1015	 * caused WANT_STOP to be set. If the stop then was already
1016	 * processed further, STOPPING might be set.
1017	 */
1018	if (test_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state) ||
1019	    test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
1020		ht_dbg(sta->sdata,
1021		       "got addBA resp for %pM tid %d but we already gave up\n",
1022		       sta->sta.addr, tid);
1023		return;
1024	}
1025
1026	/*
1027	 * IEEE 802.11-2007 7.3.1.14:
1028	 * In an ADDBA Response frame, when the Status Code field
1029	 * is set to 0, the Buffer Size subfield is set to a value
1030	 * of at least 1.
1031	 */
1032	if (le16_to_cpu(mgmt->u.action.u.addba_resp.status)
1033			== WLAN_STATUS_SUCCESS && buf_size) {
1034		if (test_and_set_bit(HT_AGG_STATE_RESPONSE_RECEIVED,
1035				     &tid_tx->state)) {
1036			/* ignore duplicate response */
1037			return;
1038		}
1039
1040		tid_tx->buf_size = buf_size;
1041		tid_tx->amsdu = amsdu;
1042
1043		if (test_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state))
1044			ieee80211_agg_tx_operational(local, sta, tid);
1045
1046		sta->ampdu_mlme.addba_req_num[tid] = 0;
1047
1048		tid_tx->timeout =
1049			le16_to_cpu(mgmt->u.action.u.addba_resp.timeout);
1050
1051		if (tid_tx->timeout) {
1052			mod_timer(&tid_tx->session_timer,
1053				  TU_TO_EXP_TIME(tid_tx->timeout));
1054			tid_tx->last_tx = jiffies;
1055		}
1056
1057	} else {
1058		__ieee80211_stop_tx_ba_session(sta, tid, AGG_STOP_DECLINED);
1059	}
1060}