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-2009, 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 <net/mac80211.h>
  18 #include "ieee80211_i.h"
  19 #include "wme.h"
  20
  21 /**
  22  * DOC: TX aggregation
  23  *
  24  * Aggregation on the TX side requires setting the hardware flag
  25  * %IEEE80211_HW_AMPDU_AGGREGATION as well as, if present, the @ampdu_queues
  26  * hardware parameter to the number of hardware AMPDU queues. If there are no
  27  * hardware queues then the driver will (currently) have to do all frame
  28  * buffering.
  29  *
  30  * When TX aggregation is started by some subsystem (usually the rate control
  31  * algorithm would be appropriate) by calling the
  32  * ieee80211_start_tx_ba_session() function, the driver will be notified via
  33  * its @ampdu_action function, with the %IEEE80211_AMPDU_TX_START action.
  34  *
  35  * In response to that, the driver is later required to call the
  36  * ieee80211_start_tx_ba_cb() (or ieee80211_start_tx_ba_cb_irqsafe())
  37  * function, which will start the aggregation session.
  38  *
  39  * Similarly, when the aggregation session is stopped by
  40  * ieee80211_stop_tx_ba_session(), the driver's @ampdu_action function will
  41  * be called with the action %IEEE80211_AMPDU_TX_STOP. In this case, the
  42  * call must not fail, and the driver must later call ieee80211_stop_tx_ba_cb()
  43  * (or ieee80211_stop_tx_ba_cb_irqsafe()).
  44  */
  45
  46 static void ieee80211_send_addba_request(struct ieee80211_sub_if_data *sdata,
  47                                          const u8 *da, u16 tid,
  48                                          u8 dialog_token, u16 start_seq_num,
  49                                          u16 agg_size, u16 timeout)
  50 {
  51         struct ieee80211_local *local = sdata->local;
  52         struct sk_buff *skb;
  53         struct ieee80211_mgmt *mgmt;
  54         u16 capab;
  55
  56         skb = dev_alloc_skb(sizeof(*mgmt) + local->hw.extra_tx_headroom);
  57
  58         if (!skb) {
  59                 printk(KERN_ERR "%s: failed to allocate buffer "
  60                                 "for addba request frame\n", sdata->dev->name);
  61                 return;
  62         }
  63         skb_reserve(skb, local->hw.extra_tx_headroom);
  64         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
  65         memset(mgmt, 0, 24);
  66         memcpy(mgmt->da, da, ETH_ALEN);
  67         memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
  68         if (sdata->vif.type == NL80211_IFTYPE_AP ||
  69             sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
  70                 memcpy(mgmt->bssid, sdata->dev->dev_addr, ETH_ALEN);
  71         else if (sdata->vif.type == NL80211_IFTYPE_STATION)
  72                 memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
  73
  74         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  75                                           IEEE80211_STYPE_ACTION);
  76
  77         skb_put(skb, 1 + sizeof(mgmt->u.action.u.addba_req));
  78
  79         mgmt->u.action.category = WLAN_CATEGORY_BACK;
  80         mgmt->u.action.u.addba_req.action_code = WLAN_ACTION_ADDBA_REQ;
  81
  82         mgmt->u.action.u.addba_req.dialog_token = dialog_token;
  83         capab = (u16)(1 << 1);          /* bit 1 aggregation policy */
  84         capab |= (u16)(tid << 2);       /* bit 5:2 TID number */
  85         capab |= (u16)(agg_size << 6);  /* bit 15:6 max size of aggergation */
  86
  87         mgmt->u.action.u.addba_req.capab = cpu_to_le16(capab);
  88
  89         mgmt->u.action.u.addba_req.timeout = cpu_to_le16(timeout);
  90         mgmt->u.action.u.addba_req.start_seq_num =
  91                                         cpu_to_le16(start_seq_num << 4);
  92
  93         ieee80211_tx_skb(sdata, skb, 1);
  94 }
  95
  96 void ieee80211_send_bar(struct ieee80211_sub_if_data *sdata, u8 *ra, u16 tid, u16 ssn)
  97 {
  98         struct ieee80211_local *local = sdata->local;
  99         struct sk_buff *skb;
 100         struct ieee80211_bar *bar;
 101         u16 bar_control = 0;
 102
 103         skb = dev_alloc_skb(sizeof(*bar) + local->hw.extra_tx_headroom);
 104         if (!skb) {
 105                 printk(KERN_ERR "%s: failed to allocate buffer for "
 106                         "bar frame\n", sdata->dev->name);
 107                 return;
 108         }
 109         skb_reserve(skb, local->hw.extra_tx_headroom);
 110         bar = (struct ieee80211_bar *)skb_put(skb, sizeof(*bar));
 111         memset(bar, 0, sizeof(*bar));
 112         bar->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
 113                                          IEEE80211_STYPE_BACK_REQ);
 114         memcpy(bar->ra, ra, ETH_ALEN);
 115         memcpy(bar->ta, sdata->dev->dev_addr, ETH_ALEN);
 116         bar_control |= (u16)IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL;
 117         bar_control |= (u16)IEEE80211_BAR_CTRL_CBMTID_COMPRESSED_BA;
 118         bar_control |= (u16)(tid << 12);
 119         bar->control = cpu_to_le16(bar_control);
 120         bar->start_seq_num = cpu_to_le16(ssn);
 121
 122         ieee80211_tx_skb(sdata, skb, 0);
 123 }
 124
 125 static int ___ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 126                                            enum ieee80211_back_parties initiator)
 127 {
 128         struct ieee80211_local *local = sta->local;
 129         int ret;
 130         u8 *state;
 131
 132         state = &sta->ampdu_mlme.tid_state_tx[tid];
 133
 134         if (local->hw.ampdu_queues) {
 135                 if (initiator) {
 136                         /*
 137                          * Stop the AC queue to avoid issues where we send
 138                          * unaggregated frames already before the delba.
 139                          */
 140                         ieee80211_stop_queue_by_reason(&local->hw,
 141                                 local->hw.queues + sta->tid_to_tx_q[tid],
 142                                 IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
 143                 }
 144
 145                 /*
 146                  * Pretend the driver woke the queue, just in case
 147                  * it disabled it before the session was stopped.
 148                  */
 149                 ieee80211_wake_queue(
 150                         &local->hw, local->hw.queues + sta->tid_to_tx_q[tid]);
 151         }
 152         *state = HT_AGG_STATE_REQ_STOP_BA_MSK |
 153                 (initiator << HT_AGG_STATE_INITIATOR_SHIFT);
 154
 155         ret = local->ops->ampdu_action(&local->hw, IEEE80211_AMPDU_TX_STOP,
 156                                        &sta->sta, tid, NULL);
 157
 158         /* HW shall not deny going back to legacy */
 159         if (WARN_ON(ret)) {
 160                 *state = HT_AGG_STATE_OPERATIONAL;
 161         }
 162
 163         return ret;
 164 }
 165
 166 /*
 167  * After sending add Block Ack request we activated a timer until
 168  * add Block Ack response will arrive from the recipient.
 169  * If this timer expires sta_addba_resp_timer_expired will be executed.
 170  */
 171 static void sta_addba_resp_timer_expired(unsigned long data)
 172 {
 173         /* not an elegant detour, but there is no choice as the timer passes
 174          * only one argument, and both sta_info and TID are needed, so init
 175          * flow in sta_info_create gives the TID as data, while the timer_to_id
 176          * array gives the sta through container_of */
 177         u16 tid = *(u8 *)data;
 178         struct sta_info *sta = container_of((void *)data,
 179                 struct sta_info, timer_to_tid[tid]);
 180         u8 *state;
 181
 182         state = &sta->ampdu_mlme.tid_state_tx[tid];
 183
 184         /* check if the TID waits for addBA response */
 185         spin_lock_bh(&sta->lock);
 186         if (!(*state & HT_ADDBA_REQUESTED_MSK)) {
 187                 spin_unlock_bh(&sta->lock);
 188                 *state = HT_AGG_STATE_IDLE;
 189 #ifdef CONFIG_MAC80211_HT_DEBUG
 190                 printk(KERN_DEBUG "timer expired on tid %d but we are not "
 191                                 "expecting addBA response there", tid);
 192 #endif
 193                 return;
 194         }
 195
 196 #ifdef CONFIG_MAC80211_HT_DEBUG
 197         printk(KERN_DEBUG "addBA response timer expired on tid %d\n", tid);
 198 #endif
 199
 200         ___ieee80211_stop_tx_ba_session(sta, tid, WLAN_BACK_INITIATOR);
 201         spin_unlock_bh(&sta->lock);
 202 }
 203
 204 static inline int ieee80211_ac_from_tid(int tid)
 205 {
 206         return ieee802_1d_to_ac[tid & 7];
 207 }
 208
 209 int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid)
 210 {
 211         struct ieee80211_local *local = hw_to_local(hw);
 212         struct sta_info *sta;
 213         struct ieee80211_sub_if_data *sdata;
 214         u8 *state;
 215         int i, qn = -1, ret = 0;
 216         u16 start_seq_num;
 217
 218         if (WARN_ON(!local->ops->ampdu_action))
 219                 return -EINVAL;
 220
 221         if ((tid >= STA_TID_NUM) || !(hw->flags & IEEE80211_HW_AMPDU_AGGREGATION))
 222                 return -EINVAL;
 223
 224 #ifdef CONFIG_MAC80211_HT_DEBUG
 225         printk(KERN_DEBUG "Open BA session requested for %pM tid %u\n",
 226                ra, tid);
 227 #endif /* CONFIG_MAC80211_HT_DEBUG */
 228
 229         if (hw->ampdu_queues && ieee80211_ac_from_tid(tid) == 0) {
 230 #ifdef CONFIG_MAC80211_HT_DEBUG
 231                 printk(KERN_DEBUG "rejecting on voice AC\n");
 232 #endif
 233                 return -EINVAL;
 234         }
 235
 236         rcu_read_lock();
 237
 238         sta = sta_info_get(local, ra);
 239         if (!sta) {
 240 #ifdef CONFIG_MAC80211_HT_DEBUG
 241                 printk(KERN_DEBUG "Could not find the station\n");
 242 #endif
 243                 ret = -ENOENT;
 244                 goto unlock;
 245         }
 246
 247         /*
 248          * The aggregation code is not prepared to handle
 249          * anything but STA/AP due to the BSSID handling.
 250          * IBSS could work in the code but isn't supported
 251          * by drivers or the standard.
 252          */
 253         if (sta->sdata->vif.type != NL80211_IFTYPE_STATION &&
 254             sta->sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
 255             sta->sdata->vif.type != NL80211_IFTYPE_AP) {
 256                 ret = -EINVAL;
 257                 goto unlock;
 258         }
 259
 260         if (test_sta_flags(sta, WLAN_STA_SUSPEND)) {
 261 #ifdef CONFIG_MAC80211_HT_DEBUG
 262                 printk(KERN_DEBUG "Suspend in progress. "
 263                        "Denying BA session request\n");
 264 #endif
 265                 ret = -EINVAL;
 266                 goto unlock;
 267         }
 268
 269         spin_lock_bh(&sta->lock);
 270
 271         sdata = sta->sdata;
 272
 273         /* we have tried too many times, receiver does not want A-MPDU */
 274         if (sta->ampdu_mlme.addba_req_num[tid] > HT_AGG_MAX_RETRIES) {
 275                 ret = -EBUSY;
 276                 goto err_unlock_sta;
 277         }
 278
 279         state = &sta->ampdu_mlme.tid_state_tx[tid];
 280         /* check if the TID is not in aggregation flow already */
 281         if (*state != HT_AGG_STATE_IDLE) {
 282 #ifdef CONFIG_MAC80211_HT_DEBUG
 283                 printk(KERN_DEBUG "BA request denied - session is not "
 284                                  "idle on tid %u\n", tid);
 285 #endif /* CONFIG_MAC80211_HT_DEBUG */
 286                 ret = -EAGAIN;
 287                 goto err_unlock_sta;
 288         }
 289
 290         if (hw->ampdu_queues) {
 291                 spin_lock(&local->queue_stop_reason_lock);
 292                 /* reserve a new queue for this session */
 293                 for (i = 0; i < local->hw.ampdu_queues; i++) {
 294                         if (local->ampdu_ac_queue[i] < 0) {
 295                                 qn = i;
 296                                 local->ampdu_ac_queue[qn] =
 297                                         ieee80211_ac_from_tid(tid);
 298                                 break;
 299                         }
 300                 }
 301                 spin_unlock(&local->queue_stop_reason_lock);
 302
 303                 if (qn < 0) {
 304 #ifdef CONFIG_MAC80211_HT_DEBUG
 305                         printk(KERN_DEBUG "BA request denied - "
 306                                "queue unavailable for tid %d\n", tid);
 307 #endif /* CONFIG_MAC80211_HT_DEBUG */
 308                         ret = -ENOSPC;
 309                         goto err_unlock_sta;
 310                 }
 311
 312                 /*
 313                  * If we successfully allocate the session, we can't have
 314                  * anything going on on the queue this TID maps into, so
 315                  * stop it for now. This is a "virtual" stop using the same
 316                  * mechanism that drivers will use.
 317                  *
 318                  * XXX: queue up frames for this session in the sta_info
 319                  *      struct instead to avoid hitting all other STAs.
 320                  */
 321                 ieee80211_stop_queue_by_reason(
 322                         &local->hw, hw->queues + qn,
 323                         IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
 324         }
 325
 326         /* prepare A-MPDU MLME for Tx aggregation */
 327         sta->ampdu_mlme.tid_tx[tid] =
 328                         kmalloc(sizeof(struct tid_ampdu_tx), GFP_ATOMIC);
 329         if (!sta->ampdu_mlme.tid_tx[tid]) {
 330 #ifdef CONFIG_MAC80211_HT_DEBUG
 331                 if (net_ratelimit())
 332                         printk(KERN_ERR "allocate tx mlme to tid %d failed\n",
 333                                         tid);
 334 #endif
 335                 ret = -ENOMEM;
 336                 goto err_return_queue;
 337         }
 338
 339         /* Tx timer */
 340         sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.function =
 341                         sta_addba_resp_timer_expired;
 342         sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.data =
 343                         (unsigned long)&sta->timer_to_tid[tid];
 344         init_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
 345
 346         /* Ok, the Addba frame hasn't been sent yet, but if the driver calls the
 347          * call back right away, it must see that the flow has begun */
 348         *state |= HT_ADDBA_REQUESTED_MSK;
 349
 350         start_seq_num = sta->tid_seq[tid];
 351
 352         ret = local->ops->ampdu_action(hw, IEEE80211_AMPDU_TX_START,
 353                                        &sta->sta, tid, &start_seq_num);
 354
 355         if (ret) {
 356 #ifdef CONFIG_MAC80211_HT_DEBUG
 357                 printk(KERN_DEBUG "BA request denied - HW unavailable for"
 358                                         " tid %d\n", tid);
 359 #endif /* CONFIG_MAC80211_HT_DEBUG */
 360                 *state = HT_AGG_STATE_IDLE;
 361                 goto err_free;
 362         }
 363         sta->tid_to_tx_q[tid] = qn;
 364
 365         spin_unlock_bh(&sta->lock);
 366
 367         /* send an addBA request */
 368         sta->ampdu_mlme.dialog_token_allocator++;
 369         sta->ampdu_mlme.tid_tx[tid]->dialog_token =
 370                         sta->ampdu_mlme.dialog_token_allocator;
 371         sta->ampdu_mlme.tid_tx[tid]->ssn = start_seq_num;
 372
 373         ieee80211_send_addba_request(sta->sdata, ra, tid,
 374                          sta->ampdu_mlme.tid_tx[tid]->dialog_token,
 375                          sta->ampdu_mlme.tid_tx[tid]->ssn,
 376                          0x40, 5000);
 377         /* activate the timer for the recipient's addBA response */
 378         sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer.expires =
 379                                 jiffies + ADDBA_RESP_INTERVAL;
 380         add_timer(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
 381 #ifdef CONFIG_MAC80211_HT_DEBUG
 382         printk(KERN_DEBUG "activated addBA response timer on tid %d\n", tid);
 383 #endif
 384         goto unlock;
 385
 386  err_free:
 387         kfree(sta->ampdu_mlme.tid_tx[tid]);
 388         sta->ampdu_mlme.tid_tx[tid] = NULL;
 389  err_return_queue:
 390         if (qn >= 0) {
 391                 /* We failed, so start queue again right away. */
 392                 ieee80211_wake_queue_by_reason(hw, hw->queues + qn,
 393                         IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
 394                 /* give queue back to pool */
 395                 spin_lock(&local->queue_stop_reason_lock);
 396                 local->ampdu_ac_queue[qn] = -1;
 397                 spin_unlock(&local->queue_stop_reason_lock);
 398         }
 399  err_unlock_sta:
 400         spin_unlock_bh(&sta->lock);
 401  unlock:
 402         rcu_read_unlock();
 403         return ret;
 404 }
 405 EXPORT_SYMBOL(ieee80211_start_tx_ba_session);
 406
 407 static void ieee80211_agg_tx_operational(struct ieee80211_local *local,
 408                                          struct sta_info *sta, u16 tid)
 409 {
 410 #ifdef CONFIG_MAC80211_HT_DEBUG
 411         printk(KERN_DEBUG "Aggregation is on for tid %d \n", tid);
 412 #endif
 413
 414         if (local->hw.ampdu_queues) {
 415                 /*
 416                  * Wake up the A-MPDU queue, we stopped it earlier,
 417                  * this will in turn wake the entire AC.
 418                  */
 419                 ieee80211_wake_queue_by_reason(&local->hw,
 420                         local->hw.queues + sta->tid_to_tx_q[tid],
 421                         IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
 422         }
 423
 424         local->ops->ampdu_action(&local->hw, IEEE80211_AMPDU_TX_OPERATIONAL,
 425                                  &sta->sta, tid, NULL);
 426 }
 427
 428 void ieee80211_start_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u16 tid)
 429 {
 430         struct ieee80211_local *local = hw_to_local(hw);
 431         struct sta_info *sta;
 432         u8 *state;
 433
 434         if (tid >= STA_TID_NUM) {
 435 #ifdef CONFIG_MAC80211_HT_DEBUG
 436                 printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
 437                                 tid, STA_TID_NUM);
 438 #endif
 439                 return;
 440         }
 441
 442         rcu_read_lock();
 443         sta = sta_info_get(local, ra);
 444         if (!sta) {
 445                 rcu_read_unlock();
 446 #ifdef CONFIG_MAC80211_HT_DEBUG
 447                 printk(KERN_DEBUG "Could not find station: %pM\n", ra);
 448 #endif
 449                 return;
 450         }
 451
 452         state = &sta->ampdu_mlme.tid_state_tx[tid];
 453         spin_lock_bh(&sta->lock);
 454
 455         if (WARN_ON(!(*state & HT_ADDBA_REQUESTED_MSK))) {
 456 #ifdef CONFIG_MAC80211_HT_DEBUG
 457                 printk(KERN_DEBUG "addBA was not requested yet, state is %d\n",
 458                                 *state);
 459 #endif
 460                 spin_unlock_bh(&sta->lock);
 461                 rcu_read_unlock();
 462                 return;
 463         }
 464
 465         if (WARN_ON(*state & HT_ADDBA_DRV_READY_MSK))
 466                 goto out;
 467
 468         *state |= HT_ADDBA_DRV_READY_MSK;
 469
 470         if (*state == HT_AGG_STATE_OPERATIONAL)
 471                 ieee80211_agg_tx_operational(local, sta, tid);
 472
 473  out:
 474         spin_unlock_bh(&sta->lock);
 475         rcu_read_unlock();
 476 }
 477 EXPORT_SYMBOL(ieee80211_start_tx_ba_cb);
 478
 479 void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_hw *hw,
 480                                       const u8 *ra, u16 tid)
 481 {
 482         struct ieee80211_local *local = hw_to_local(hw);
 483         struct ieee80211_ra_tid *ra_tid;
 484         struct sk_buff *skb = dev_alloc_skb(0);
 485
 486         if (unlikely(!skb)) {
 487 #ifdef CONFIG_MAC80211_HT_DEBUG
 488                 if (net_ratelimit())
 489                         printk(KERN_WARNING "%s: Not enough memory, "
 490                                "dropping start BA session", skb->dev->name);
 491 #endif
 492                 return;
 493         }
 494         ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
 495         memcpy(&ra_tid->ra, ra, ETH_ALEN);
 496         ra_tid->tid = tid;
 497
 498         skb->pkt_type = IEEE80211_ADDBA_MSG;
 499         skb_queue_tail(&local->skb_queue, skb);
 500         tasklet_schedule(&local->tasklet);
 501 }
 502 EXPORT_SYMBOL(ieee80211_start_tx_ba_cb_irqsafe);
 503
 504 int __ieee80211_stop_tx_ba_session(struct sta_info *sta, u16 tid,
 505                                    enum ieee80211_back_parties initiator)
 506 {
 507         u8 *state;
 508         int ret;
 509
 510         /* check if the TID is in aggregation */
 511         state = &sta->ampdu_mlme.tid_state_tx[tid];
 512         spin_lock_bh(&sta->lock);
 513
 514         if (*state != HT_AGG_STATE_OPERATIONAL) {
 515                 ret = -ENOENT;
 516                 goto unlock;
 517         }
 518
 519 #ifdef CONFIG_MAC80211_HT_DEBUG
 520         printk(KERN_DEBUG "Tx BA session stop requested for %pM tid %u\n",
 521                sta->sta.addr, tid);
 522 #endif /* CONFIG_MAC80211_HT_DEBUG */
 523
 524         ret = ___ieee80211_stop_tx_ba_session(sta, tid, initiator);
 525
 526  unlock:
 527         spin_unlock_bh(&sta->lock);
 528         return ret;
 529 }
 530
 531 int ieee80211_stop_tx_ba_session(struct ieee80211_hw *hw,
 532                                  u8 *ra, u16 tid,
 533                                  enum ieee80211_back_parties initiator)
 534 {
 535         struct ieee80211_local *local = hw_to_local(hw);
 536         struct sta_info *sta;
 537         int ret = 0;
 538
 539         if (WARN_ON(!local->ops->ampdu_action))
 540                 return -EINVAL;
 541
 542         if (tid >= STA_TID_NUM)
 543                 return -EINVAL;
 544
 545         rcu_read_lock();
 546         sta = sta_info_get(local, ra);
 547         if (!sta) {
 548                 rcu_read_unlock();
 549                 return -ENOENT;
 550         }
 551
 552         ret = __ieee80211_stop_tx_ba_session(sta, tid, initiator);
 553         rcu_read_unlock();
 554         return ret;
 555 }
 556 EXPORT_SYMBOL(ieee80211_stop_tx_ba_session);
 557
 558 void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid)
 559 {
 560         struct ieee80211_local *local = hw_to_local(hw);
 561         struct sta_info *sta;
 562         u8 *state;
 563
 564         if (tid >= STA_TID_NUM) {
 565 #ifdef CONFIG_MAC80211_HT_DEBUG
 566                 printk(KERN_DEBUG "Bad TID value: tid = %d (>= %d)\n",
 567                                 tid, STA_TID_NUM);
 568 #endif
 569                 return;
 570         }
 571
 572 #ifdef CONFIG_MAC80211_HT_DEBUG
 573         printk(KERN_DEBUG "Stopping Tx BA session for %pM tid %d\n",
 574                ra, tid);
 575 #endif /* CONFIG_MAC80211_HT_DEBUG */
 576
 577         rcu_read_lock();
 578         sta = sta_info_get(local, ra);
 579         if (!sta) {
 580 #ifdef CONFIG_MAC80211_HT_DEBUG
 581                 printk(KERN_DEBUG "Could not find station: %pM\n", ra);
 582 #endif
 583                 rcu_read_unlock();
 584                 return;
 585         }
 586         state = &sta->ampdu_mlme.tid_state_tx[tid];
 587
 588         /* NOTE: no need to use sta->lock in this state check, as
 589          * ieee80211_stop_tx_ba_session will let only one stop call to
 590          * pass through per sta/tid
 591          */
 592         if ((*state & HT_AGG_STATE_REQ_STOP_BA_MSK) == 0) {
 593 #ifdef CONFIG_MAC80211_HT_DEBUG
 594                 printk(KERN_DEBUG "unexpected callback to A-MPDU stop\n");
 595 #endif
 596                 rcu_read_unlock();
 597                 return;
 598         }
 599
 600         if (*state & HT_AGG_STATE_INITIATOR_MSK)
 601                 ieee80211_send_delba(sta->sdata, ra, tid,
 602                         WLAN_BACK_INITIATOR, WLAN_REASON_QSTA_NOT_USE);
 603
 604         spin_lock_bh(&sta->lock);
 605
 606         if (*state & HT_AGG_STATE_INITIATOR_MSK &&
 607             hw->ampdu_queues) {
 608                 /*
 609                  * Wake up this queue, we stopped it earlier,
 610                  * this will in turn wake the entire AC.
 611                  */
 612                 ieee80211_wake_queue_by_reason(hw,
 613                         hw->queues + sta->tid_to_tx_q[tid],
 614                         IEEE80211_QUEUE_STOP_REASON_AGGREGATION);
 615         }
 616
 617         *state = HT_AGG_STATE_IDLE;
 618         sta->ampdu_mlme.addba_req_num[tid] = 0;
 619         kfree(sta->ampdu_mlme.tid_tx[tid]);
 620         sta->ampdu_mlme.tid_tx[tid] = NULL;
 621         spin_unlock_bh(&sta->lock);
 622
 623         rcu_read_unlock();
 624 }
 625 EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb);
 626
 627 void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_hw *hw,
 628                                      const u8 *ra, u16 tid)
 629 {
 630         struct ieee80211_local *local = hw_to_local(hw);
 631         struct ieee80211_ra_tid *ra_tid;
 632         struct sk_buff *skb = dev_alloc_skb(0);
 633
 634         if (unlikely(!skb)) {
 635 #ifdef CONFIG_MAC80211_HT_DEBUG
 636                 if (net_ratelimit())
 637                         printk(KERN_WARNING "%s: Not enough memory, "
 638                                "dropping stop BA session", skb->dev->name);
 639 #endif
 640                 return;
 641         }
 642         ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
 643         memcpy(&ra_tid->ra, ra, ETH_ALEN);
 644         ra_tid->tid = tid;
 645
 646         skb->pkt_type = IEEE80211_DELBA_MSG;
 647         skb_queue_tail(&local->skb_queue, skb);
 648         tasklet_schedule(&local->tasklet);
 649 }
 650 EXPORT_SYMBOL(ieee80211_stop_tx_ba_cb_irqsafe);
 651
 652
 653 void ieee80211_process_addba_resp(struct ieee80211_local *local,
 654                                   struct sta_info *sta,
 655                                   struct ieee80211_mgmt *mgmt,
 656                                   size_t len)
 657 {
 658         u16 capab, tid;
 659         u8 *state;
 660
 661         capab = le16_to_cpu(mgmt->u.action.u.addba_resp.capab);
 662         tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
 663
 664         state = &sta->ampdu_mlme.tid_state_tx[tid];
 665
 666         spin_lock_bh(&sta->lock);
 667
 668         if (!(*state & HT_ADDBA_REQUESTED_MSK)) {
 669                 spin_unlock_bh(&sta->lock);
 670                 return;
 671         }
 672
 673         if (mgmt->u.action.u.addba_resp.dialog_token !=
 674                 sta->ampdu_mlme.tid_tx[tid]->dialog_token) {
 675                 spin_unlock_bh(&sta->lock);
 676 #ifdef CONFIG_MAC80211_HT_DEBUG
 677                 printk(KERN_DEBUG "wrong addBA response token, tid %d\n", tid);
 678 #endif /* CONFIG_MAC80211_HT_DEBUG */
 679                 return;
 680         }
 681
 682         del_timer_sync(&sta->ampdu_mlme.tid_tx[tid]->addba_resp_timer);
 683 #ifdef CONFIG_MAC80211_HT_DEBUG
 684         printk(KERN_DEBUG "switched off addBA timer for tid %d \n", tid);
 685 #endif /* CONFIG_MAC80211_HT_DEBUG */
 686         if (le16_to_cpu(mgmt->u.action.u.addba_resp.status)
 687                         == WLAN_STATUS_SUCCESS) {
 688                 u8 curstate = *state;
 689
 690                 *state |= HT_ADDBA_RECEIVED_MSK;
 691
 692                 if (*state != curstate && *state == HT_AGG_STATE_OPERATIONAL)
 693                         ieee80211_agg_tx_operational(local, sta, tid);
 694
 695                 sta->ampdu_mlme.addba_req_num[tid] = 0;
 696         } else {
 697                 sta->ampdu_mlme.addba_req_num[tid]++;
 698                 ___ieee80211_stop_tx_ba_session(sta, tid, WLAN_BACK_INITIATOR);
 699         }
 700         spin_unlock_bh(&sta->lock);
 701 }