net/mac80211/agg-tx.c

   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  *
  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.
  14  */
  15
  16 #include <linux/ieee80211.h>
  17 #include <linux/slab.h>
  18 #include <linux/export.h>
  19 #include <net/mac80211.h>
  20 #include "ieee80211_i.h"
  21 #include "driver-ops.h"
  22 #include "wme.h"
  23
  24 /**
  25  * DOC: TX A-MPDU aggregation
  26  *
  27  * Aggregation on the TX side requires setting the hardware flag
  28  * %IEEE80211_HW_AMPDU_AGGREGATION. The driver will then be handed
  29  * packets with a flag indicating A-MPDU aggregation. The driver
  30  * or device is responsible for actually aggregating the frames,
  31  * as well as deciding how many and which to aggregate.
  32  *
  33  * When TX aggregation is started by some subsystem (usually the rate
  34  * control algorithm would be appropriate) by calling the
  35  * ieee80211_start_tx_ba_session() function, the driver will be
  36  * notified via its @ampdu_action function, with the
  37  * %IEEE80211_AMPDU_TX_START action.
  38  *
  39  * In response to that, the driver is later required to call the
  40  * ieee80211_start_tx_ba_cb_irqsafe() function, which will really
  41  * start the aggregation session after the peer has also responded.
  42  * If the peer responds negatively, the session will be stopped
  43  * again right away. Note that it is possible for the aggregation
  44  * session to be stopped before the driver has indicated that it
  45  * is done setting it up, in which case it must not indicate the
  46  * setup completion.
  47  *
  48  * Also note that, since we also need to wait for a response from
  49  * the peer, the driver is notified of the completion of the
  50  * handshake by the %IEEE80211_AMPDU_TX_OPERATIONAL action to the
  51  * @ampdu_action callback.
  52  *
  53  * Similarly, when the aggregation session is stopped by the peer
  54  * or something calling ieee80211_stop_tx_ba_session(), the driver's
  55  * @ampdu_action function will be called with the action
  56  * %IEEE80211_AMPDU_TX_STOP. In this case, the call must not fail,
  57  * and the driver must later call ieee80211_stop_tx_ba_cb_irqsafe().
  58  */
  59
  60 static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
  61                                          const u8 *da, u16 tid,
  62                                          u8 dialog_token, u16 start_seq_num,
  63                                          u16 agg_size, u16 timeout)
  64 {
  65         struct ieee80211_local *local = sdata->local;
  66         struct sk_buff *skb;
  67         struct ieee80211_mgmt *mgmt;
  68         u16 capab;
  69
  70         skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
  71
  72         if (!skb)
  73                 return;
  74
  75         skb_reserve(skb, local->hw.extra_tx_headroom);
  76         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
  77         memset(mgmt, 0, 24);
  78         memcpy(mgmt->da, da, ETH_ALEN);
  79         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
  80         if (sdata->vif.type == NL80211_IFTYPE_AP ||
  81             sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
  82             sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
  83                 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
  84         else if (sdata->vif.type == NL80211_IFTYPE_STATION)
  85                 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
  86         else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
  87                 memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN);
  88
  89         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  90                                           IEEE80211_STYPE_ACTION);
  91
  92         skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_req));
  93
  94         mgmt->u.action.category = WLAN_CATEGORY_BACK;
  95         mgmt->u.action.u.addba_req.action_code = WLAN_ACTION_ADDBA_REQ;
  96
  97         mgmt->u.action.u.addba_req.dialog_token = dialog_token;
  98         capab = (u16)(1 << 1);          /* bit 1 aggregation policy */
  99         capab |= (u16)(tid << 2);       /* bit 5:2 TID number */
 100         capab |= (u16)(agg_size << 6);  /* bit 15:6 max size of aggergation */
 101
 102         mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);
 103
 104         mgmt->u.action.u.addba_req.timeout = cpu_to_le16(timeout);
 105         mgmt->u.action.u.addba_req.start_seq_num =
 106                                         cpu_to_le16(start_seq_num << 4);
 107
 108         ieee80211_tx_skb(sdata, skb);
 109 }
 110
 111 void ieee80211_send_bar(struct ieee80211_vif *vif, u8 *ra, u16 tid, u16 ssn)
 112 {
 113         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 114         struct ieee80211_local *local = sdata->local;
 115         struct sk_buff *skb;
 116         struct ieee80211_bar *bar;
 117         u16 bar_control = 0;
 118
 119         skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom);
 120         if (!skb)
 121                 return;
 122
 123         skb_reserve(skb, local->hw.extra_tx_headroom);
 124         bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar));
 125         memset(bar, 0, sizeof(*bar));
 126         bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
 127                                          IEEE80211_STYPE_BACK_REQ);
 128         memcpy(bar->ra, ra, ETH_ALEN);
 129         memcpy(bar->ta, sdata->vif.addr, ETH_ALEN);
 130         bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL;
 131         bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA;
 132         bar_control |= (u16)(tid << IEEE80211_BAR_CTRL_TID_INFO_SHIFT);
 133         bar->control = cpu_to_le16(bar_control);
 134         bar->start_seq_num = cpu_to_le16(ssn);
 135
 136         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
 137         ieee80211_tx_skb(sdata, skb);
 138 }
 139 EXPORT_SYMBOL(ieee80211_send_bar);
 140
 141 void ieee80211_assign_tid_tx(struct sta_info *sta, int tid,
 142                              struct tid_ampdu_tx *tid_tx)
 143 {
 144         lockdep_assert_held(&sta->ampdu_mlme.mtx);
 145         lockdep_assert_held(&sta->lock);
 146         rcu_assign_pointer(sta->ampdu_mlme.tid_tx[tid], tid_tx);
 147 }
 148
 149 int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 150                                     enum ieee80211_back_parties initiator,
 151                                     bool tx)
 152 {
 153         struct ieee80211_local *local = sta->local;
 154         struct tid_ampdu_tx *tid_tx;
 155         int ret;
 156
 157         lockdep_assert_held(&sta->ampdu_mlme.mtx);
 158
 159         spin_lock_bh(&sta->lock);
 160
 161         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 162         if (!tid_tx) {
 163                 spin_unlock_bh(&sta->lock);
 164                 return -ENOENT;
 165         }
 166
 167         /* if we're already stopping ignore any new requests to stop */
 168         if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 169                 spin_unlock_bh(&sta->lock);
 170                 return -EALREADY;
 171         }
 172
 173         if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
 174                 /* not even started yet! */
 175                 ieee80211_assign_tid_tx(sta, tid, NULL);
 176                 spin_unlock_bh(&sta->lock);
 177                 kfree_rcu(tid_tx, rcu_head);
 178                 return 0;
 179         }
 180
 181         set_bit(HT_AGG_STATE_STOPPING, &tid_tx->state);
 182
 183         spin_unlock_bh(&sta->lock);
 184
 185 #ifdef CONFIG_MAC80211_HT_DEBUG
 186         printk(KERN_DEBUG "Tx BA session stop requested for %pM tid %u\n",
 187                sta->sta.addr, tid);
 188 #endif /* CONFIG_MAC80211_HT_DEBUG */
 189
 190         del_timer_sync(&tid_tx->addba_resp_timer);
 191         del_timer_sync(&tid_tx->session_timer);
 192
 193         /*
 194          * After this packets are no longer handed right through
 195          * to the driver but are put onto tid_tx->pending instead,
 196          * with locking to ensure proper access.
 197          */
 198         clear_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
 199
 200         /*
 201          * There might be a few packets being processed right now (on
 202          * another CPU) that have already gotten past the aggregation
 203          * check when it was still OPERATIONAL and consequently have
 204          * IEEE80211_TX_CTL_AMPDU set. In that case, this code might
 205          * call into the driver at the same time or even before the
 206          * TX paths calls into it, which could confuse the driver.
 207          *
 208          * Wait for all currently running TX paths to finish before
 209          * telling the driver. New packets will not go through since
 210          * the aggregation session is no longer OPERATIONAL.
 211          */
 212         synchronize_net();
 213
 214         tid_tx->stop_initiator = initiator;
 215         tid_tx->tx_stop = tx;
 216
 217         ret = drv_ampdu_action(local, sta->sdata,
 218                                IEEE80211_AMPDU_TX_STOP,
 219                                &sta->sta, tid, NULL, 0);
 220
 221         /* HW shall not deny going back to legacy */
 222         if (WARN_ON(ret)) {
 223                 /*
 224                  * We may have pending packets get stuck in this case...
 225                  * Not bothering with a workaround for now.
 226                  */
 227         }
 228
 229         return ret;
 230 }
 231
 232 /*
 233  * After sending add Block Ack request we activated a timer until
 234  * add Block Ack response will arrive from the recipient.
 235  * If this timer expires sta_addba_resp_timer_expired will be executed.
 236  */
 237 static void sta_addba_resp_timer_expired(unsigned long data)
 238 {
 239         /* not an elegant detour, but there is no choice as the timer passes
 240          * only one argument, and both sta_info and TID are needed, so init
 241          * flow in sta_info_create gives the TID as data, while the timer_to_id
 242          * array gives the sta through container_of */
 243         u16 tid = *(u8 *)data;
 244         struct sta_info *sta = container_of((void *)data,
 245                 struct sta_info, timer_to_tid[tid]);
 246         struct tid_ampdu_tx *tid_tx;
 247
 248         /* check if the TID waits for addBA response */
 249         rcu_read_lock();
 250         tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
 251         if (!tid_tx ||
 252             test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state)) {
 253                 rcu_read_unlock();
 254 #ifdef CONFIG_MAC80211_HT_DEBUG
 255                 printk(KERN_DEBUG "timer expired on tid %d but we are not "
 256                                 "(or no longer) expecting addBA response there\n",
 257                         tid);
 258 #endif
 259                 return;
 260         }
 261
 262 #ifdef CONFIG_MAC80211_HT_DEBUG
 263         printk(KERN_DEBUG "addBA response timer expired on tid %d\n", tid);
 264 #endif
 265
 266         ieee80211_stop_tx_ba_session(&sta->sta, tid);
 267         rcu_read_unlock();
 268 }
 269
 270 static inline int ieee80211_ac_from_tid(int tid)
 271 {
 272         return ieee802_1d_to_ac[tid & 7];
 273 }
 274
 275 /*
 276  * When multiple aggregation sessions on multiple stations
 277  * are being created/destroyed simultaneously, we need to
 278  * refcount the global queue stop caused by that in order
 279  * to not get into a situation where one of the aggregation
 280  * setup or teardown re-enables queues before the other is
 281  * ready to handle that.
 282  *
 283  * These two functions take care of this issue by keeping
 284  * a global "agg_queue_stop" refcount.
 285  */
 286 static void __acquires(agg_queue)
 287 ieee80211_stop_queue_agg(struct ieee80211_local *local, int tid)
 288 {
 289         int queue = ieee80211_ac_from_tid(tid);
 290
 291         if (atomic_inc_return(&local->agg_queue_stop[queue]) == 1)
 292                 ieee80211_stop_queue_by_reason(
 293                         &local->hw, queue,
 294                         IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
 295         __acquire(agg_queue);
 296 }
 297
 298 static void __releases(agg_queue)
 299 ieee80211_wake_queue_agg(struct ieee80211_local *local, int tid)
 300 {
 301         int queue = ieee80211_ac_from_tid(tid);
 302
 303         if (atomic_dec_return(&local->agg_queue_stop[queue]) == 0)
 304                 ieee80211_wake_queue_by_reason(
 305                         &local->hw, queue,
 306                         IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
 307         __release(agg_queue);
 308 }
 309
 310 void ieee80211_tx_ba_session_handle_start(struct sta_info *sta, int tid)
 311 {
 312         struct tid_ampdu_tx *tid_tx;
 313         struct ieee80211_local *local = sta->local;
 314         struct ieee80211_sub_if_data *sdata = sta->sdata;
 315         u16 start_seq_num;
 316         int ret;
 317
 318         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 319
 320         /*
 321          * While we're asking the driver about the aggregation,
 322          * stop the AC queue so that we don't have to worry
 323          * about frames that came in while we were doing that,
 324          * which would require us to put them to the AC pending
 325          * afterwards which just makes the code more complex.
 326          */
 327         ieee80211_stop_queue_agg(local, tid);
 328
 329         clear_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
 330
 331         /*
 332          * make sure no packets are being processed to get
 333          * valid starting sequence number
 334          */
 335         synchronize_net();
 336
 337         start_seq_num = sta->tid_seq[tid] >> 4;
 338
 339         ret = drv_ampdu_action(local, sdata, IEEE80211_AMPDU_TX_START,
 340                                &sta->sta, tid, &start_seq_num, 0);
 341         if (ret) {
 342 #ifdef CONFIG_MAC80211_HT_DEBUG
 343                 printk(KERN_DEBUG "BA request denied - HW unavailable for"
 344                                         " tid %d\n", tid);
 345 #endif
 346                 spin_lock_bh(&sta->lock);
 347                 ieee80211_assign_tid_tx(sta, tid, NULL);
 348                 spin_unlock_bh(&sta->lock);
 349
 350                 ieee80211_wake_queue_agg(local, tid);
 351                 kfree_rcu(tid_tx, rcu_head);
 352                 return;
 353         }
 354
 355         /* we can take packets again now */
 356         ieee80211_wake_queue_agg(local, tid);
 357
 358         /* activate the timer for the recipient's addBA response */
 359         mod_timer(&tid_tx->addba_resp_timer, jiffies + ADDBA_RESP_INTERVAL);
 360 #ifdef CONFIG_MAC80211_HT_DEBUG
 361         printk(KERN_DEBUG "activated addBA response timer on tid %d\n", tid);
 362 #endif
 363
 364         spin_lock_bh(&sta->lock);
 365         sta->ampdu_mlme.addba_req_num[tid]++;
 366         spin_unlock_bh(&sta->lock);
 367
 368         /* send AddBA request */
 369         ieee80211_send_addba_request(sdata, sta->sta.addr, tid,
 370                                      tid_tx->dialog_token, start_seq_num,
 371                                      local->hw.max_tx_aggregation_subframes,
 372                                      tid_tx->timeout);
 373 }
 374
 375 /*
 376  * After accepting the AddBA Response we activated a timer,
 377  * resetting it after each frame that we send.
 378  */
 379 static void sta_tx_agg_session_timer_expired(unsigned long data)
 380 {
 381         /* not an elegant detour, but there is no choice as the timer passes
 382          * only one argument, and various sta_info are needed here, so init
 383          * flow in sta_info_create gives the TID as data, while the timer_to_id
 384          * array gives the sta through container_of */
 385         u8 *ptid = (u8 *)data;
 386         u8 *timer_to_id = ptid - *ptid;
 387         struct sta_info *sta = container_of(timer_to_id, struct sta_info,
 388                                          timer_to_tid[0]);
 389
 390 #ifdef CONFIG_MAC80211_HT_DEBUG
 391         printk(KERN_DEBUG "tx session timer expired on tid %d\n", (u16)*ptid);
 392 #endif
 393
 394         ieee80211_stop_tx_ba_session(&sta->sta, *ptid);
 395 }
 396
 397 int ieee80211_start_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid,
 398                                   u16 timeout)
 399 {
 400         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
 401         struct ieee80211_sub_if_data *sdata = sta->sdata;
 402         struct ieee80211_local *local = sdata->local;
 403         struct tid_ampdu_tx *tid_tx;
 404         int ret = 0;
 405
 406         trace_api_start_tx_ba_session(pubsta, tid);
 407
 408         if (WARN_ON(!local->ops->ampdu_action))
 409                 return -EINVAL;
 410
 411         if ((tid >= STA_TID_NUM) ||
 412             !(local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION) ||
 413             (local->hw.flags & IEEE80211_HW_TX_AMPDU_SETUP_IN_HW))
 414                 return -EINVAL;
 415
 416 #ifdef CONFIG_MAC80211_HT_DEBUG
 417         printk(KERN_DEBUG "Open BA session requested for %pM tid %u\n",
 418                pubsta->addr, tid);
 419 #endif /* CONFIG_MAC80211_HT_DEBUG */
 420
 421         if (sdata->vif.type != NL80211_IFTYPE_STATION &&
 422             sdata->vif.type != NL80211_IFTYPE_MESH_POINT &&
 423             sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
 424             sdata->vif.type != NL80211_IFTYPE_AP &&
 425             sdata->vif.type != NL80211_IFTYPE_ADHOC)
 426                 return -EINVAL;
 427
 428         if (test_sta_flag(sta, WLAN_STA_BLOCK_BA)) {
 429 #ifdef CONFIG_MAC80211_HT_DEBUG
 430                 printk(KERN_DEBUG "BA sessions blocked. "
 431                        "Denying BA session request\n");
 432 #endif
 433                 return -EINVAL;
 434         }
 435
 436         /*
 437          * 802.11n-2009 11.5.1.1: If the initiating STA is an HT STA, is a
 438          * member of an IBSS, and has no other existing Block Ack agreement
 439          * with the recipient STA, then the initiating STA shall transmit a
 440          * Probe Request frame to the recipient STA and shall not transmit an
 441          * ADDBA Request frame unless it receives a Probe Response frame
 442          * from the recipient within dot11ADDBAFailureTimeout.
 443          *
 444          * The probe request mechanism for ADDBA is currently not implemented,
 445          * but we only build up Block Ack session with HT STAs. This information
 446          * is set when we receive a bss info from a probe response or a beacon.
 447          */
 448         if (sta->sdata->vif.type == NL80211_IFTYPE_ADHOC &&
 449             !sta->sta.ht_cap.ht_supported) {
 450 #ifdef CONFIG_MAC80211_HT_DEBUG
 451                 printk(KERN_DEBUG "BA request denied - IBSS STA %pM"
 452                        "does not advertise HT support\n", pubsta->addr);
 453 #endif /* CONFIG_MAC80211_HT_DEBUG */
 454                 return -EINVAL;
 455         }
 456
 457         spin_lock_bh(&sta->lock);
 458
 459         /* we have tried too many times, receiver does not want A-MPDU */
 460         if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) {
 461                 ret = -EBUSY;
 462                 goto err_unlock_sta;
 463         }
 464
 465         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 466         /* check if the TID is not in aggregation flow already */
 467         if (tid_tx || sta->ampdu_mlme.tid_start_tx[tid]) {
 468 #ifdef CONFIG_MAC80211_HT_DEBUG
 469                 printk(KERN_DEBUG "BA request denied - session is not "
 470                                  "idle on tid %u\n", tid);
 471 #endif /* CONFIG_MAC80211_HT_DEBUG */
 472                 ret = -EAGAIN;
 473                 goto err_unlock_sta;
 474         }
 475
 476         /* prepare A-MPDU MLME for Tx aggregation */
 477         tid_tx = kzalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
 478         if (!tid_tx) {
 479                 ret = -ENOMEM;
 480                 goto err_unlock_sta;
 481         }
 482
 483         skb_queue_head_init(&tid_tx->pending);
 484         __set_bit(HT_AGG_STATE_WANT_START, &tid_tx->state);
 485
 486         tid_tx->timeout = timeout;
 487
 488         /* response timer */
 489         tid_tx->addba_resp_timer.function = sta_addba_resp_timer_expired;
 490         tid_tx->addba_resp_timer.data = (unsigned long)&sta->timer_to_tid[tid];
 491         init_timer(&tid_tx->addba_resp_timer);
 492
 493         /* tx timer */
 494         tid_tx->session_timer.function = sta_tx_agg_session_timer_expired;
 495         tid_tx->session_timer.data = (unsigned long)&sta->timer_to_tid[tid];
 496         init_timer(&tid_tx->session_timer);
 497
 498         /* assign a dialog token */
 499         sta->ampdu_mlme.dialog_token_allocator++;
 500         tid_tx->dialog_token = sta->ampdu_mlme.dialog_token_allocator;
 501
 502         /*
 503          * Finally, assign it to the start array; the work item will
 504          * collect it and move it to the normal array.
 505          */
 506         sta->ampdu_mlme.tid_start_tx[tid] = tid_tx;
 507
 508         ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
 509
 510         /* this flow continues off the work */
 511  err_unlock_sta:
 512         spin_unlock_bh(&sta->lock);
 513         return ret;
 514 }
 515 EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
 516
 517 /*
 518  * splice packets from the STA's pending to the local pending,
 519  * requires a call to ieee80211_agg_splice_finish later
 520  */
 521 static void __acquires(agg_queue)
 522 ieee80211_agg_splice_packets(struct ieee80211_local *local,
 523                              struct tid_ampdu_tx *tid_tx, u16 tid)
 524 {
 525         int queue = ieee80211_ac_from_tid(tid);
 526         unsigned long flags;
 527
 528         ieee80211_stop_queue_agg(local, tid);
 529
 530         if (WARN(!tid_tx, "TID %d gone but expected when splicing aggregates"
 531                           " from the pending queue\n", tid))
 532                 return;
 533
 534         if (!skb_queue_empty(&tid_tx->pending)) {
 535                 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 536                 /* copy over remaining packets */
 537                 skb_queue_splice_tail_init(&tid_tx->pending,
 538                                            &local->pending[queue]);
 539                 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 540         }
 541 }
 542
 543 static void __releases(agg_queue)
 544 ieee80211_agg_splice_finish(struct ieee80211_local *local, u16 tid)
 545 {
 546         ieee80211_wake_queue_agg(local, tid);
 547 }
 548
 549 static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
 550                                          struct sta_info *sta, u16 tid)
 551 {
 552         struct tid_ampdu_tx *tid_tx;
 553
 554         lockdep_assert_held(&sta->ampdu_mlme.mtx);
 555
 556         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 557
 558 #ifdef CONFIG_MAC80211_HT_DEBUG
 559         printk(KERN_DEBUG "Aggregation is on for tid %d\n", tid);
 560 #endif
 561
 562         drv_ampdu_action(local, sta->sdata,
 563                          IEEE80211_AMPDU_TX_OPERATIONAL,
 564                          &sta->sta, tid, NULL, tid_tx->buf_size);
 565
 566         /*
 567          * synchronize with TX path, while splicing the TX path
 568          * should block so it won't put more packets onto pending.
 569          */
 570         spin_lock_bh(&sta->lock);
 571
 572         ieee80211_agg_splice_packets(local, tid_tx, tid);
 573         /*
 574          * Now mark as operational. This will be visible
 575          * in the TX path, and lets it go lock-free in
 576          * the common case.
 577          */
 578         set_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state);
 579         ieee80211_agg_splice_finish(local, tid);
 580
 581         spin_unlock_bh(&sta->lock);
 582 }
 583
 584 void ieee80211_start_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u16 tid)
 585 {
 586         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 587         struct ieee80211_local *local = sdata->local;
 588         struct sta_info *sta;
 589         struct tid_ampdu_tx *tid_tx;
 590
 591         trace_api_start_tx_ba_cb(sdata, ra, tid);
 592
 593         if (tid >= STA_TID_NUM) {
 594 #ifdef CONFIG_MAC80211_HT_DEBUG
 595                 printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
 596                                 tid, STA_TID_NUM);
 597 #endif
 598                 return;
 599         }
 600
 601         mutex_lock(&local->sta_mtx);
 602         sta = sta_info_get_bss(sdata, ra);
 603         if (!sta) {
 604                 mutex_unlock(&local->sta_mtx);
 605 #ifdef CONFIG_MAC80211_HT_DEBUG
 606                 printk(KERN_DEBUG "Could not find station: %pM\n", ra);
 607 #endif
 608                 return;
 609         }
 610
 611         mutex_lock(&sta->ampdu_mlme.mtx);
 612         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 613
 614         if (WARN_ON(!tid_tx)) {
 615 #ifdef CONFIG_MAC80211_HT_DEBUG
 616                 printk(KERN_DEBUG "addBA was not requested!\n");
 617 #endif
 618                 goto unlock;
 619         }
 620
 621         if (WARN_ON(test_and_set_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state)))
 622                 goto unlock;
 623
 624         if (test_bit(HT_AGG_STATE_RESPONSE_RECEIVED, &tid_tx->state))
 625                 ieee80211_agg_tx_operational(local, sta, tid);
 626
 627  unlock:
 628         mutex_unlock(&sta->ampdu_mlme.mtx);
 629         mutex_unlock(&local->sta_mtx);
 630 }
 631
 632 void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
 633                                       const u8 *ra, u16 tid)
 634 {
 635         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 636         struct ieee80211_local *local = sdata->local;
 637         struct ieee80211_ra_tid *ra_tid;
 638         struct sk_buff *skb = dev_alloc_skb(0);
 639
 640         if (unlikely(!skb))
 641                 return;
 642
 643         ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
 644         memcpy(&ra_tid->ra, ra, ETH_ALEN);
 645         ra_tid->tid = tid;
 646
 647         skb->pkt_type = IEEE80211_SDATA_QUEUE_AGG_START;
 648         skb_queue_tail(&sdata->skb_queue, skb);
 649         ieee80211_queue_work(&local->hw, &sdata->work);
 650 }
 651 EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe);
 652
 653 int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 654                                    enum ieee80211_back_parties initiator,
 655                                    bool tx)
 656 {
 657         int ret;
 658
 659         mutex_lock(&sta->ampdu_mlme.mtx);
 660
 661         ret = ___ieee80211_stop_tx_ba_session(sta, tid, initiator, tx);
 662
 663         mutex_unlock(&sta->ampdu_mlme.mtx);
 664
 665         return ret;
 666 }
 667
 668 int ieee80211_stop_tx_ba_session(struct ieee80211_sta *pubsta, u16 tid)
 669 {
 670         struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
 671         struct ieee80211_sub_if_data *sdata = sta->sdata;
 672         struct ieee80211_local *local = sdata->local;
 673         struct tid_ampdu_tx *tid_tx;
 674         int ret = 0;
 675
 676         trace_api_stop_tx_ba_session(pubsta, tid);
 677
 678         if (!local->ops->ampdu_action)
 679                 return -EINVAL;
 680
 681         if (tid >= STA_TID_NUM)
 682                 return -EINVAL;
 683
 684         spin_lock_bh(&sta->lock);
 685         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 686
 687         if (!tid_tx) {
 688                 ret = -ENOENT;
 689                 goto unlock;
 690         }
 691
 692         if (test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 693                 /* already in progress stopping it */
 694                 ret = 0;
 695                 goto unlock;
 696         }
 697
 698         set_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state);
 699         ieee80211_queue_work(&local->hw, &sta->ampdu_mlme.work);
 700
 701  unlock:
 702         spin_unlock_bh(&sta->lock);
 703         return ret;
 704 }
 705 EXPORT_SYMBOL(ieee80211_stop_tx_ba_session);
 706
 707 void ieee80211_stop_tx_ba_cb(struct ieee80211_vif *vif, u8 *ra, u8 tid)
 708 {
 709         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 710         struct ieee80211_local *local = sdata->local;
 711         struct sta_info *sta;
 712         struct tid_ampdu_tx *tid_tx;
 713
 714         trace_api_stop_tx_ba_cb(sdata, ra, tid);
 715
 716         if (tid >= STA_TID_NUM) {
 717 #ifdef CONFIG_MAC80211_HT_DEBUG
 718                 printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
 719                                 tid, STA_TID_NUM);
 720 #endif
 721                 return;
 722         }
 723
 724 #ifdef CONFIG_MAC80211_HT_DEBUG
 725         printk(KERN_DEBUG "Stopping Tx BA session for %pM tid %d\n",
 726                ra, tid);
 727 #endif /* CONFIG_MAC80211_HT_DEBUG */
 728
 729         mutex_lock(&local->sta_mtx);
 730
 731         sta = sta_info_get_bss(sdata, ra);
 732         if (!sta) {
 733 #ifdef CONFIG_MAC80211_HT_DEBUG
 734                 printk(KERN_DEBUG "Could not find station: %pM\n", ra);
 735 #endif
 736                 goto unlock;
 737         }
 738
 739         mutex_lock(&sta->ampdu_mlme.mtx);
 740         spin_lock_bh(&sta->lock);
 741         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 742
 743         if (!tid_tx || !test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 744 #ifdef CONFIG_MAC80211_HT_DEBUG
 745                 printk(KERN_DEBUG "unexpected callback to A-MPDU stop\n");
 746 #endif
 747                 goto unlock_sta;
 748         }
 749
 750         if (tid_tx->stop_initiator == WLAN_BACK_INITIATOR && tid_tx->tx_stop)
 751                 ieee80211_send_delba(sta->sdata, ra, tid,
 752                         WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
 753
 754         /*
 755          * When we get here, the TX path will not be lockless any more wrt.
 756          * aggregation, since the OPERATIONAL bit has long been cleared.
 757          * Thus it will block on getting the lock, if it occurs. So if we
 758          * stop the queue now, we will not get any more packets, and any
 759          * that might be being processed will wait for us here, thereby
 760          * guaranteeing that no packets go to the tid_tx pending queue any
 761          * more.
 762          */
 763
 764         ieee80211_agg_splice_packets(local, tid_tx, tid);
 765
 766         /* future packets must not find the tid_tx struct any more */
 767         ieee80211_assign_tid_tx(sta, tid, NULL);
 768
 769         ieee80211_agg_splice_finish(local, tid);
 770
 771         kfree_rcu(tid_tx, rcu_head);
 772
 773  unlock_sta:
 774         spin_unlock_bh(&sta->lock);
 775         mutex_unlock(&sta->ampdu_mlme.mtx);
 776  unlock:
 777         mutex_unlock(&local->sta_mtx);
 778 }
 779
 780 void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_vif *vif,
 781                                      const u8 *ra, u16 tid)
 782 {
 783         struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
 784         struct ieee80211_local *local = sdata->local;
 785         struct ieee80211_ra_tid *ra_tid;
 786         struct sk_buff *skb = dev_alloc_skb(0);
 787
 788         if (unlikely(!skb))
 789                 return;
 790
 791         ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
 792         memcpy(&ra_tid->ra, ra, ETH_ALEN);
 793         ra_tid->tid = tid;
 794
 795         skb->pkt_type = IEEE80211_SDATA_QUEUE_AGG_STOP;
 796         skb_queue_tail(&sdata->skb_queue, skb);
 797         ieee80211_queue_work(&local->hw, &sdata->work);
 798 }
 799 EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe);
 800
 801
 802 void ieee80211_process_addba_resp(struct ieee80211_local *local,
 803                                   struct sta_info *sta,
 804                                   struct ieee80211_mgmt *mgmt,
 805                                   size_t len)
 806 {
 807         struct tid_ampdu_tx *tid_tx;
 808         u16 capab, tid;
 809         u8 buf_size;
 810
 811         capab = le16_to_cpu(mgmt->u.action.u.addba_resp.capab);
 812         tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
 813         buf_size = (capab & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK) >> 6;
 814
 815         mutex_lock(&sta->ampdu_mlme.mtx);
 816
 817         tid_tx = rcu_dereference_protected_tid_tx(sta, tid);
 818         if (!tid_tx)
 819                 goto out;
 820
 821         if (mgmt->u.action.u.addba_resp.dialog_token != tid_tx->dialog_token) {
 822 #ifdef CONFIG_MAC80211_HT_DEBUG
 823                 printk(KERN_DEBUG "wrong addBA response token, tid %d\n", tid);
 824 #endif
 825                 goto out;
 826         }
 827
 828         del_timer_sync(&tid_tx->addba_resp_timer);
 829
 830 #ifdef CONFIG_MAC80211_HT_DEBUG
 831         printk(KERN_DEBUG "switched off addBA timer for tid %d\n", tid);
 832 #endif
 833
 834         /*
 835          * addba_resp_timer may have fired before we got here, and
 836          * caused WANT_STOP to be set. If the stop then was already
 837          * processed further, STOPPING might be set.
 838          */
 839         if (test_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state) ||
 840             test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
 841 #ifdef CONFIG_MAC80211_HT_DEBUG
 842                 printk(KERN_DEBUG
 843                        "got addBA resp for tid %d but we already gave up\n",
 844                        tid);
 845 #endif
 846                 goto out;
 847         }
 848
 849         /*
 850          * IEEE 802.11-2007 7.3.1.14:
 851          * In an ADDBA Response frame, when the Status Code field
 852          * is set to 0, the Buffer Size subfield is set to a value
 853          * of at least 1.
 854          */
 855         if (le16_to_cpu(mgmt->u.action.u.addba_resp.status)
 856                         == WLAN_STATUS_SUCCESS && buf_size) {
 857                 if (test_and_set_bit(HT_AGG_STATE_RESPONSE_RECEIVED,
 858                                      &tid_tx->state)) {
 859                         /* ignore duplicate response */
 860                         goto out;
 861                 }
 862
 863                 tid_tx->buf_size = buf_size;
 864
 865                 if (test_bit(HT_AGG_STATE_DRV_READY, &tid_tx->state))
 866                         ieee80211_agg_tx_operational(local, sta, tid);
 867
 868                 sta->ampdu_mlme.addba_req_num[tid] = 0;
 869
 870                 if (tid_tx->timeout)
 871                         mod_timer(&tid_tx->session_timer,
 872                                   TU_TO_EXP_TIME(tid_tx->timeout));
 873
 874         } else {
 875                 ___ieee80211_stop_tx_ba_session(sta, tid, WLAN_BACK_INITIATOR,
 876                                                 true);
 877         }
 878
 879  out:
 880         mutex_unlock(&sta->ampdu_mlme.mtx);
 881 }