drivers/net/wireless/ath9k/xmit.c

   1 /*
   2  * Copyright (c) 2008 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 /*
  18  * Implementation of transmit path.
  19  */
  20
  21 #include "core.h"
  22
  23 #define BITS_PER_BYTE           8
  24 #define OFDM_PLCP_BITS          22
  25 #define HT_RC_2_MCS(_rc)        ((_rc) & 0x0f)
  26 #define HT_RC_2_STREAMS(_rc)    ((((_rc) & 0x78) >> 3) + 1)
  27 #define L_STF                   8
  28 #define L_LTF                   8
  29 #define L_SIG                   4
  30 #define HT_SIG                  8
  31 #define HT_STF                  4
  32 #define HT_LTF(_ns)             (4 * (_ns))
  33 #define SYMBOL_TIME(_ns)        ((_ns) << 2) /* ns * 4 us */
  34 #define SYMBOL_TIME_HALFGI(_ns) (((_ns) * 18 + 4) / 5)  /* ns * 3.6 us */
  35 #define NUM_SYMBOLS_PER_USEC(_usec) (_usec >> 2)
  36 #define NUM_SYMBOLS_PER_USEC_HALFGI(_usec) (((_usec*5)-4)/18)
  37
  38 #define OFDM_SIFS_TIME              16
  39
  40 static u32 bits_per_symbol[][2] = {
  41         /* 20MHz 40MHz */
  42         {    26,   54 },     /*  0: BPSK */
  43         {    52,  108 },     /*  1: QPSK 1/2 */
  44         {    78,  162 },     /*  2: QPSK 3/4 */
  45         {   104,  216 },     /*  3: 16-QAM 1/2 */
  46         {   156,  324 },     /*  4: 16-QAM 3/4 */
  47         {   208,  432 },     /*  5: 64-QAM 2/3 */
  48         {   234,  486 },     /*  6: 64-QAM 3/4 */
  49         {   260,  540 },     /*  7: 64-QAM 5/6 */
  50         {    52,  108 },     /*  8: BPSK */
  51         {   104,  216 },     /*  9: QPSK 1/2 */
  52         {   156,  324 },     /* 10: QPSK 3/4 */
  53         {   208,  432 },     /* 11: 16-QAM 1/2 */
  54         {   312,  648 },     /* 12: 16-QAM 3/4 */
  55         {   416,  864 },     /* 13: 64-QAM 2/3 */
  56         {   468,  972 },     /* 14: 64-QAM 3/4 */
  57         {   520, 1080 },     /* 15: 64-QAM 5/6 */
  58 };
  59
  60 #define IS_HT_RATE(_rate)     ((_rate) & 0x80)
  61
  62 /*
  63  * Insert a chain of ath_buf (descriptors) on a txq and
  64  * assume the descriptors are already chained together by caller.
  65  * NB: must be called with txq lock held
  66  */
  67
  68 static void ath_tx_txqaddbuf(struct ath_softc *sc,
  69                 struct ath_txq *txq, struct list_head *head)
  70 {
  71         struct ath_hal *ah = sc->sc_ah;
  72         struct ath_buf *bf;
  73         /*
  74          * Insert the frame on the outbound list and
  75          * pass it on to the hardware.
  76          */
  77
  78         if (list_empty(head))
  79                 return;
  80
  81         bf = list_first_entry(head, struct ath_buf, list);
  82
  83         list_splice_tail_init(head, &txq->axq_q);
  84         txq->axq_depth++;
  85         txq->axq_totalqueued++;
  86         txq->axq_linkbuf = list_entry(txq->axq_q.prev, struct ath_buf, list);
  87
  88         DPRINTF(sc, ATH_DBG_QUEUE,
  89                 "%s: txq depth = %d\n", __func__, txq->axq_depth);
  90
  91         if (txq->axq_link == NULL) {
  92                 ath9k_hw_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
  93                 DPRINTF(sc, ATH_DBG_XMIT,
  94                         "%s: TXDP[%u] = %llx (%p)\n",
  95                         __func__, txq->axq_qnum,
  96                         ito64(bf->bf_daddr), bf->bf_desc);
  97         } else {
  98                 *txq->axq_link = bf->bf_daddr;
  99                 DPRINTF(sc, ATH_DBG_XMIT, "%s: link[%u] (%p)=%llx (%p)\n",
 100                         __func__,
 101                         txq->axq_qnum, txq->axq_link,
 102                         ito64(bf->bf_daddr), bf->bf_desc);
 103         }
 104         txq->axq_link = &(bf->bf_lastbf->bf_desc->ds_link);
 105         ath9k_hw_txstart(ah, txq->axq_qnum);
 106 }
 107
 108 /* Get transmit rate index using rate in Kbps */
 109
 110 static int ath_tx_findindex(const struct ath9k_rate_table *rt, int rate)
 111 {
 112         int i;
 113         int ndx = 0;
 114
 115         for (i = 0; i < rt->rateCount; i++) {
 116                 if (rt->info[i].rateKbps == rate) {
 117                         ndx = i;
 118                         break;
 119                 }
 120         }
 121
 122         return ndx;
 123 }
 124
 125 /* Check if it's okay to send out aggregates */
 126
 127 static int ath_aggr_query(struct ath_softc *sc,
 128         struct ath_node *an, u8 tidno)
 129 {
 130         struct ath_atx_tid *tid;
 131         tid = ATH_AN_2_TID(an, tidno);
 132
 133         if (tid->addba_exchangecomplete || tid->addba_exchangeinprogress)
 134                 return 1;
 135         else
 136                 return 0;
 137 }
 138
 139 static enum ath9k_pkt_type get_hal_packet_type(struct ieee80211_hdr *hdr)
 140 {
 141         enum ath9k_pkt_type htype;
 142         __le16 fc;
 143
 144         fc = hdr->frame_control;
 145
 146         /* Calculate Atheros packet type from IEEE80211 packet header */
 147
 148         if (ieee80211_is_beacon(fc))
 149                 htype = ATH9K_PKT_TYPE_BEACON;
 150         else if (ieee80211_is_probe_resp(fc))
 151                 htype = ATH9K_PKT_TYPE_PROBE_RESP;
 152         else if (ieee80211_is_atim(fc))
 153                 htype = ATH9K_PKT_TYPE_ATIM;
 154         else if (ieee80211_is_pspoll(fc))
 155                 htype = ATH9K_PKT_TYPE_PSPOLL;
 156         else
 157                 htype = ATH9K_PKT_TYPE_NORMAL;
 158
 159         return htype;
 160 }
 161
 162 static void fill_min_rates(struct sk_buff *skb, struct ath_tx_control *txctl)
 163 {
 164         struct ieee80211_hdr *hdr;
 165         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
 166         struct ath_tx_info_priv *tx_info_priv;
 167         __le16 fc;
 168
 169         hdr = (struct ieee80211_hdr *)skb->data;
 170         fc = hdr->frame_control;
 171
 172         /* XXX: HACK! */
 173         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
 174
 175         if (ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc)) {
 176                 txctl->use_minrate = 1;
 177                 txctl->min_rate = tx_info_priv->min_rate;
 178         } else if (ieee80211_is_data(fc)) {
 179                 if (ieee80211_is_nullfunc(fc) ||
 180                                 /* Port Access Entity (IEEE 802.1X) */
 181                                 (skb->protocol == cpu_to_be16(ETH_P_PAE))) {
 182                         txctl->use_minrate = 1;
 183                         txctl->min_rate = tx_info_priv->min_rate;
 184                 }
 185                 if (is_multicast_ether_addr(hdr->addr1))
 186                         txctl->mcast_rate = tx_info_priv->min_rate;
 187         }
 188
 189 }
 190
 191 /* This function will setup additional txctl information, mostly rate stuff */
 192 /* FIXME: seqno, ps */
 193 static int ath_tx_prepare(struct ath_softc *sc,
 194                           struct sk_buff *skb,
 195                           struct ath_tx_control *txctl)
 196 {
 197         struct ieee80211_hw *hw = sc->hw;
 198         struct ieee80211_hdr *hdr;
 199         struct ath_rc_series *rcs;
 200         struct ath_txq *txq = NULL;
 201         const struct ath9k_rate_table *rt;
 202         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
 203         struct ath_tx_info_priv *tx_info_priv;
 204         int hdrlen;
 205         u8 rix, antenna;
 206         __le16 fc;
 207         u8 *qc;
 208
 209         txctl->dev = sc;
 210         hdr = (struct ieee80211_hdr *)skb->data;
 211         hdrlen = ieee80211_get_hdrlen_from_skb(skb);
 212         fc = hdr->frame_control;
 213
 214         rt = sc->sc_currates;
 215         BUG_ON(!rt);
 216
 217         /* Fill misc fields */
 218
 219         spin_lock_bh(&sc->node_lock);
 220         txctl->an = ath_node_get(sc, hdr->addr1);
 221         /* create a temp node, if the node is not there already */
 222         if (!txctl->an)
 223                 txctl->an = ath_node_attach(sc, hdr->addr1, 0);
 224         spin_unlock_bh(&sc->node_lock);
 225
 226         if (ieee80211_is_data_qos(fc)) {
 227                 qc = ieee80211_get_qos_ctl(hdr);
 228                 txctl->tidno = qc[0] & 0xf;
 229         }
 230
 231         txctl->if_id = 0;
 232         txctl->frmlen = skb->len + FCS_LEN - (hdrlen & 3);
 233
 234         /* Always try at highest power possible unless the the device
 235          * was configured by the user to use another power. */
 236         if (likely(sc->sc_config.txpowlimit == ATH_TXPOWER_MAX))
 237                 txctl->txpower = ATH_TXPOWER_MAX;
 238         else
 239                 txctl->txpower = sc->sc_config.txpowlimit;
 240
 241         /* Fill Key related fields */
 242
 243         txctl->keytype = ATH9K_KEY_TYPE_CLEAR;
 244         txctl->keyix = ATH9K_TXKEYIX_INVALID;
 245
 246         if (tx_info->control.hw_key) {
 247                 txctl->keyix = tx_info->control.hw_key->hw_key_idx;
 248                 txctl->frmlen += tx_info->control.hw_key->icv_len;
 249
 250                 if (tx_info->control.hw_key->alg == ALG_WEP)
 251                         txctl->keytype = ATH9K_KEY_TYPE_WEP;
 252                 else if (tx_info->control.hw_key->alg == ALG_TKIP)
 253                         txctl->keytype = ATH9K_KEY_TYPE_TKIP;
 254                 else if (tx_info->control.hw_key->alg == ALG_CCMP)
 255                         txctl->keytype = ATH9K_KEY_TYPE_AES;
 256         }
 257
 258         /* Fill packet type */
 259
 260         txctl->atype = get_hal_packet_type(hdr);
 261
 262         /* Fill qnum */
 263
 264         if (unlikely(txctl->flags & ATH9K_TXDESC_CAB)) {
 265                 txctl->qnum = 0;
 266                 txq = sc->sc_cabq;
 267         } else {
 268                 txctl->qnum = ath_get_hal_qnum(skb_get_queue_mapping(skb), sc);
 269                 txq = &sc->sc_txq[txctl->qnum];
 270         }
 271         spin_lock_bh(&txq->axq_lock);
 272
 273         /* Try to avoid running out of descriptors */
 274         if (txq->axq_depth >= (ATH_TXBUF - 20) &&
 275             !(txctl->flags & ATH9K_TXDESC_CAB)) {
 276                 DPRINTF(sc, ATH_DBG_FATAL,
 277                         "%s: TX queue: %d is full, depth: %d\n",
 278                         __func__,
 279                         txctl->qnum,
 280                         txq->axq_depth);
 281                 ieee80211_stop_queue(hw, skb_get_queue_mapping(skb));
 282                 txq->stopped = 1;
 283                 spin_unlock_bh(&txq->axq_lock);
 284                 return -1;
 285         }
 286
 287         spin_unlock_bh(&txq->axq_lock);
 288
 289         /* Fill rate */
 290
 291         fill_min_rates(skb, txctl);
 292
 293         /* Fill flags */
 294
 295         txctl->flags |= ATH9K_TXDESC_CLRDMASK /* needed for crypto errors */
 296                 | ATH9K_TXDESC_INTREQ; /* Generate an interrupt */
 297
 298         if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK)
 299                 txctl->flags |= ATH9K_TXDESC_NOACK;
 300
 301         if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
 302                 txctl->flags |= ATH9K_TXDESC_RTSENA;
 303
 304         /*
 305          * Setup for rate calculations.
 306          */
 307
 308         /* XXX: HACK! */
 309         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
 310         rcs = tx_info_priv->rcs;
 311
 312         if (ieee80211_is_data(fc) && !txctl->use_minrate) {
 313
 314                 /* Enable HT only for DATA frames and not for EAPOL */
 315                 /* XXX why AMPDU only?? */
 316                 txctl->ht = (hw->conf.ht.enabled &&
 317                             (tx_info->flags & IEEE80211_TX_CTL_AMPDU));
 318
 319                 if (is_multicast_ether_addr(hdr->addr1)) {
 320                         rcs[0].rix = (u8)
 321                                 ath_tx_findindex(rt, txctl->mcast_rate);
 322
 323                         /*
 324                          * mcast packets are not re-tried.
 325                          */
 326                         rcs[0].tries = 1;
 327                 }
 328                 /* For HT capable stations, we save tidno for later use.
 329                  * We also override seqno set by upper layer with the one
 330                  * in tx aggregation state.
 331                  *
 332                  * First, the fragmentation stat is determined.
 333                  * If fragmentation is on, the sequence number is
 334                  * not overridden, since it has been
 335                  * incremented by the fragmentation routine.
 336                  */
 337                 if (likely(!(txctl->flags & ATH9K_TXDESC_FRAG_IS_ON)) &&
 338                     txctl->ht && (sc->sc_flags & SC_OP_TXAGGR)) {
 339                         struct ath_atx_tid *tid;
 340
 341                         tid = ATH_AN_2_TID(txctl->an, txctl->tidno);
 342
 343                         hdr->seq_ctrl = cpu_to_le16(tid->seq_next <<
 344                                 IEEE80211_SEQ_SEQ_SHIFT);
 345                         txctl->seqno = tid->seq_next;
 346                         INCR(tid->seq_next, IEEE80211_SEQ_MAX);
 347                 }
 348         } else {
 349                 /* for management and control frames,
 350                  * or for NULL and EAPOL frames */
 351                 if (txctl->min_rate)
 352                         rcs[0].rix = ath_rate_findrateix(sc, txctl->min_rate);
 353                 else
 354                         rcs[0].rix = 0;
 355                 rcs[0].tries = ATH_MGT_TXMAXTRY;
 356         }
 357         rix = rcs[0].rix;
 358
 359         if (ieee80211_has_morefrags(fc) ||
 360             (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG)) {
 361                 /*
 362                 **  Force hardware to use computed duration for next
 363                 **  fragment by disabling multi-rate retry, which
 364                 **  updates duration based on the multi-rate
 365                 **  duration table.
 366                 */
 367                 rcs[1].tries = rcs[2].tries = rcs[3].tries = 0;
 368                 rcs[1].rix = rcs[2].rix = rcs[3].rix = 0;
 369                 /* reset tries but keep rate index */
 370                 rcs[0].tries = ATH_TXMAXTRY;
 371         }
 372
 373         if (is_multicast_ether_addr(hdr->addr1)) {
 374                 antenna = sc->sc_mcastantenna + 1;
 375                 sc->sc_mcastantenna = (sc->sc_mcastantenna + 1) & 0x1;
 376         }
 377
 378         return 0;
 379 }
 380
 381 /* To complete a chain of buffers associated a frame */
 382
 383 static void ath_tx_complete_buf(struct ath_softc *sc,
 384                                 struct ath_buf *bf,
 385                                 struct list_head *bf_q,
 386                                 int txok, int sendbar)
 387 {
 388         struct sk_buff *skb = bf->bf_mpdu;
 389         struct ath_xmit_status tx_status;
 390
 391         /*
 392          * Set retry information.
 393          * NB: Don't use the information in the descriptor, because the frame
 394          * could be software retried.
 395          */
 396         tx_status.retries = bf->bf_retries;
 397         tx_status.flags = 0;
 398
 399         if (sendbar)
 400                 tx_status.flags = ATH_TX_BAR;
 401
 402         if (!txok) {
 403                 tx_status.flags |= ATH_TX_ERROR;
 404
 405                 if (bf_isxretried(bf))
 406                         tx_status.flags |= ATH_TX_XRETRY;
 407         }
 408         /* Unmap this frame */
 409         pci_unmap_single(sc->pdev,
 410                          bf->bf_dmacontext,
 411                          skb->len,
 412                          PCI_DMA_TODEVICE);
 413         /* complete this frame */
 414         ath_tx_complete(sc, skb, &tx_status, bf->bf_node);
 415
 416         /*
 417          * Return the list of ath_buf of this mpdu to free queue
 418          */
 419         spin_lock_bh(&sc->sc_txbuflock);
 420         list_splice_tail_init(bf_q, &sc->sc_txbuf);
 421         spin_unlock_bh(&sc->sc_txbuflock);
 422 }
 423
 424 /*
 425  * queue up a dest/ac pair for tx scheduling
 426  * NB: must be called with txq lock held
 427  */
 428
 429 static void ath_tx_queue_tid(struct ath_txq *txq, struct ath_atx_tid *tid)
 430 {
 431         struct ath_atx_ac *ac = tid->ac;
 432
 433         /*
 434          * if tid is paused, hold off
 435          */
 436         if (tid->paused)
 437                 return;
 438
 439         /*
 440          * add tid to ac atmost once
 441          */
 442         if (tid->sched)
 443                 return;
 444
 445         tid->sched = true;
 446         list_add_tail(&tid->list, &ac->tid_q);
 447
 448         /*
 449          * add node ac to txq atmost once
 450          */
 451         if (ac->sched)
 452                 return;
 453
 454         ac->sched = true;
 455         list_add_tail(&ac->list, &txq->axq_acq);
 456 }
 457
 458 /* pause a tid */
 459
 460 static void ath_tx_pause_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
 461 {
 462         struct ath_txq *txq = &sc->sc_txq[tid->ac->qnum];
 463
 464         spin_lock_bh(&txq->axq_lock);
 465
 466         tid->paused++;
 467
 468         spin_unlock_bh(&txq->axq_lock);
 469 }
 470
 471 /* resume a tid and schedule aggregate */
 472
 473 void ath_tx_resume_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
 474 {
 475         struct ath_txq *txq = &sc->sc_txq[tid->ac->qnum];
 476
 477         ASSERT(tid->paused > 0);
 478         spin_lock_bh(&txq->axq_lock);
 479
 480         tid->paused--;
 481
 482         if (tid->paused > 0)
 483                 goto unlock;
 484
 485         if (list_empty(&tid->buf_q))
 486                 goto unlock;
 487
 488         /*
 489          * Add this TID to scheduler and try to send out aggregates
 490          */
 491         ath_tx_queue_tid(txq, tid);
 492         ath_txq_schedule(sc, txq);
 493 unlock:
 494         spin_unlock_bh(&txq->axq_lock);
 495 }
 496
 497 /* Compute the number of bad frames */
 498
 499 static int ath_tx_num_badfrms(struct ath_softc *sc,
 500         struct ath_buf *bf, int txok)
 501 {
 502         struct ath_node *an = bf->bf_node;
 503         int isnodegone = (an->an_flags & ATH_NODE_CLEAN);
 504         struct ath_buf *bf_last = bf->bf_lastbf;
 505         struct ath_desc *ds = bf_last->bf_desc;
 506         u16 seq_st = 0;
 507         u32 ba[WME_BA_BMP_SIZE >> 5];
 508         int ba_index;
 509         int nbad = 0;
 510         int isaggr = 0;
 511
 512         if (isnodegone || ds->ds_txstat.ts_flags == ATH9K_TX_SW_ABORTED)
 513                 return 0;
 514
 515         isaggr = bf_isaggr(bf);
 516         if (isaggr) {
 517                 seq_st = ATH_DS_BA_SEQ(ds);
 518                 memcpy(ba, ATH_DS_BA_BITMAP(ds), WME_BA_BMP_SIZE >> 3);
 519         }
 520
 521         while (bf) {
 522                 ba_index = ATH_BA_INDEX(seq_st, bf->bf_seqno);
 523                 if (!txok || (isaggr && !ATH_BA_ISSET(ba, ba_index)))
 524                         nbad++;
 525
 526                 bf = bf->bf_next;
 527         }
 528
 529         return nbad;
 530 }
 531
 532 static void ath_tx_set_retry(struct ath_softc *sc, struct ath_buf *bf)
 533 {
 534         struct sk_buff *skb;
 535         struct ieee80211_hdr *hdr;
 536
 537         bf->bf_state.bf_type |= BUF_RETRY;
 538         bf->bf_retries++;
 539
 540         skb = bf->bf_mpdu;
 541         hdr = (struct ieee80211_hdr *)skb->data;
 542         hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_RETRY);
 543 }
 544
 545 /* Update block ack window */
 546
 547 static void ath_tx_update_baw(struct ath_softc *sc,
 548         struct ath_atx_tid *tid, int seqno)
 549 {
 550         int index, cindex;
 551
 552         index  = ATH_BA_INDEX(tid->seq_start, seqno);
 553         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
 554
 555         tid->tx_buf[cindex] = NULL;
 556
 557         while (tid->baw_head != tid->baw_tail && !tid->tx_buf[tid->baw_head]) {
 558                 INCR(tid->seq_start, IEEE80211_SEQ_MAX);
 559                 INCR(tid->baw_head, ATH_TID_MAX_BUFS);
 560         }
 561 }
 562
 563 /*
 564  * ath_pkt_dur - compute packet duration (NB: not NAV)
 565  *
 566  * rix - rate index
 567  * pktlen - total bytes (delims + data + fcs + pads + pad delims)
 568  * width  - 0 for 20 MHz, 1 for 40 MHz
 569  * half_gi - to use 4us v/s 3.6 us for symbol time
 570  */
 571
 572 static u32 ath_pkt_duration(struct ath_softc *sc,
 573                                   u8 rix,
 574                                   struct ath_buf *bf,
 575                                   int width,
 576                                   int half_gi,
 577                                   bool shortPreamble)
 578 {
 579         const struct ath9k_rate_table *rt = sc->sc_currates;
 580         u32 nbits, nsymbits, duration, nsymbols;
 581         u8 rc;
 582         int streams, pktlen;
 583
 584         pktlen = bf_isaggr(bf) ? bf->bf_al : bf->bf_frmlen;
 585         rc = rt->info[rix].rateCode;
 586
 587         /*
 588          * for legacy rates, use old function to compute packet duration
 589          */
 590         if (!IS_HT_RATE(rc))
 591                 return ath9k_hw_computetxtime(sc->sc_ah,
 592                                              rt,
 593                                              pktlen,
 594                                              rix,
 595                                              shortPreamble);
 596         /*
 597          * find number of symbols: PLCP + data
 598          */
 599         nbits = (pktlen << 3) + OFDM_PLCP_BITS;
 600         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
 601         nsymbols = (nbits + nsymbits - 1) / nsymbits;
 602
 603         if (!half_gi)
 604                 duration = SYMBOL_TIME(nsymbols);
 605         else
 606                 duration = SYMBOL_TIME_HALFGI(nsymbols);
 607
 608         /*
 609          * addup duration for legacy/ht training and signal fields
 610          */
 611         streams = HT_RC_2_STREAMS(rc);
 612         duration += L_STF + L_LTF + L_SIG + HT_SIG + HT_STF + HT_LTF(streams);
 613         return duration;
 614 }
 615
 616 /* Rate module function to set rate related fields in tx descriptor */
 617
 618 static void ath_buf_set_rate(struct ath_softc *sc, struct ath_buf *bf)
 619 {
 620         struct ath_hal *ah = sc->sc_ah;
 621         const struct ath9k_rate_table *rt;
 622         struct ath_desc *ds = bf->bf_desc;
 623         struct ath_desc *lastds = bf->bf_lastbf->bf_desc;
 624         struct ath9k_11n_rate_series series[4];
 625         int i, flags, rtsctsena = 0, dynamic_mimops = 0;
 626         u32 ctsduration = 0;
 627         u8 rix = 0, cix, ctsrate = 0;
 628         u32 aggr_limit_with_rts = ah->ah_caps.rts_aggr_limit;
 629         struct ath_node *an = (struct ath_node *) bf->bf_node;
 630
 631         /*
 632          * get the cix for the lowest valid rix.
 633          */
 634         rt = sc->sc_currates;
 635         for (i = 4; i--;) {
 636                 if (bf->bf_rcs[i].tries) {
 637                         rix = bf->bf_rcs[i].rix;
 638                         break;
 639                 }
 640         }
 641         flags = (bf->bf_flags & (ATH9K_TXDESC_RTSENA | ATH9K_TXDESC_CTSENA));
 642         cix = rt->info[rix].controlRate;
 643
 644         /*
 645          * If 802.11g protection is enabled, determine whether
 646          * to use RTS/CTS or just CTS.  Note that this is only
 647          * done for OFDM/HT unicast frames.
 648          */
 649         if (sc->sc_protmode != PROT_M_NONE &&
 650             (rt->info[rix].phy == PHY_OFDM ||
 651              rt->info[rix].phy == PHY_HT) &&
 652             (bf->bf_flags & ATH9K_TXDESC_NOACK) == 0) {
 653                 if (sc->sc_protmode == PROT_M_RTSCTS)
 654                         flags = ATH9K_TXDESC_RTSENA;
 655                 else if (sc->sc_protmode == PROT_M_CTSONLY)
 656                         flags = ATH9K_TXDESC_CTSENA;
 657
 658                 cix = rt->info[sc->sc_protrix].controlRate;
 659                 rtsctsena = 1;
 660         }
 661
 662         /* For 11n, the default behavior is to enable RTS for
 663          * hw retried frames. We enable the global flag here and
 664          * let rate series flags determine which rates will actually
 665          * use RTS.
 666          */
 667         if ((ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT) && bf_isdata(bf)) {
 668                 BUG_ON(!an);
 669                 /*
 670                  * 802.11g protection not needed, use our default behavior
 671                  */
 672                 if (!rtsctsena)
 673                         flags = ATH9K_TXDESC_RTSENA;
 674                 /*
 675                  * For dynamic MIMO PS, RTS needs to precede the first aggregate
 676                  * and the second aggregate should have any protection at all.
 677                  */
 678                 if (an->an_smmode == ATH_SM_PWRSAV_DYNAMIC) {
 679                         if (!bf_isaggrburst(bf)) {
 680                                 flags = ATH9K_TXDESC_RTSENA;
 681                                 dynamic_mimops = 1;
 682                         } else {
 683                                 flags = 0;
 684                         }
 685                 }
 686         }
 687
 688         /*
 689          * Set protection if aggregate protection on
 690          */
 691         if (sc->sc_config.ath_aggr_prot &&
 692             (!bf_isaggr(bf) || (bf_isaggr(bf) && bf->bf_al < 8192))) {
 693                 flags = ATH9K_TXDESC_RTSENA;
 694                 cix = rt->info[sc->sc_protrix].controlRate;
 695                 rtsctsena = 1;
 696         }
 697
 698         /*
 699          *  For AR5416 - RTS cannot be followed by a frame larger than 8K.
 700          */
 701         if (bf_isaggr(bf) && (bf->bf_al > aggr_limit_with_rts)) {
 702                 /*
 703                  * Ensure that in the case of SM Dynamic power save
 704                  * while we are bursting the second aggregate the
 705                  * RTS is cleared.
 706                  */
 707                 flags &= ~(ATH9K_TXDESC_RTSENA);
 708         }
 709
 710         /*
 711          * CTS transmit rate is derived from the transmit rate
 712          * by looking in the h/w rate table.  We must also factor
 713          * in whether or not a short preamble is to be used.
 714          */
 715         /* NB: cix is set above where RTS/CTS is enabled */
 716         BUG_ON(cix == 0xff);
 717         ctsrate = rt->info[cix].rateCode |
 718                 (bf_isshpreamble(bf) ? rt->info[cix].shortPreamble : 0);
 719
 720         /*
 721          * Setup HAL rate series
 722          */
 723         memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
 724
 725         for (i = 0; i < 4; i++) {
 726                 if (!bf->bf_rcs[i].tries)
 727                         continue;
 728
 729                 rix = bf->bf_rcs[i].rix;
 730
 731                 series[i].Rate = rt->info[rix].rateCode |
 732                         (bf_isshpreamble(bf) ? rt->info[rix].shortPreamble : 0);
 733
 734                 series[i].Tries = bf->bf_rcs[i].tries;
 735
 736                 series[i].RateFlags = (
 737                         (bf->bf_rcs[i].flags & ATH_RC_RTSCTS_FLAG) ?
 738                                 ATH9K_RATESERIES_RTS_CTS : 0) |
 739                         ((bf->bf_rcs[i].flags & ATH_RC_CW40_FLAG) ?
 740                                 ATH9K_RATESERIES_2040 : 0) |
 741                         ((bf->bf_rcs[i].flags & ATH_RC_SGI_FLAG) ?
 742                                 ATH9K_RATESERIES_HALFGI : 0);
 743
 744                 series[i].PktDuration = ath_pkt_duration(
 745                         sc, rix, bf,
 746                         (bf->bf_rcs[i].flags & ATH_RC_CW40_FLAG) != 0,
 747                         (bf->bf_rcs[i].flags & ATH_RC_SGI_FLAG),
 748                         bf_isshpreamble(bf));
 749
 750                 if ((an->an_smmode == ATH_SM_PWRSAV_STATIC) &&
 751                     (bf->bf_rcs[i].flags & ATH_RC_DS_FLAG) == 0) {
 752                         /*
 753                          * When sending to an HT node that has enabled static
 754                          * SM/MIMO power save, send at single stream rates but
 755                          * use maximum allowed transmit chains per user,
 756                          * hardware, regulatory, or country limits for
 757                          * better range.
 758                          */
 759                         series[i].ChSel = sc->sc_tx_chainmask;
 760                 } else {
 761                         if (bf_isht(bf))
 762                                 series[i].ChSel =
 763                                         ath_chainmask_sel_logic(sc, an);
 764                         else
 765                                 series[i].ChSel = sc->sc_tx_chainmask;
 766                 }
 767
 768                 if (rtsctsena)
 769                         series[i].RateFlags |= ATH9K_RATESERIES_RTS_CTS;
 770
 771                 /*
 772                  * Set RTS for all rates if node is in dynamic powersave
 773                  * mode and we are using dual stream rates.
 774                  */
 775                 if (dynamic_mimops && (bf->bf_rcs[i].flags & ATH_RC_DS_FLAG))
 776                         series[i].RateFlags |= ATH9K_RATESERIES_RTS_CTS;
 777         }
 778
 779         /*
 780          * For non-HT devices, calculate RTS/CTS duration in software
 781          * and disable multi-rate retry.
 782          */
 783         if (flags && !(ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT)) {
 784                 /*
 785                  * Compute the transmit duration based on the frame
 786                  * size and the size of an ACK frame.  We call into the
 787                  * HAL to do the computation since it depends on the
 788                  * characteristics of the actual PHY being used.
 789                  *
 790                  * NB: CTS is assumed the same size as an ACK so we can
 791                  *     use the precalculated ACK durations.
 792                  */
 793                 if (flags & ATH9K_TXDESC_RTSENA) {    /* SIFS + CTS */
 794                         ctsduration += bf_isshpreamble(bf) ?
 795                                 rt->info[cix].spAckDuration :
 796                                 rt->info[cix].lpAckDuration;
 797                 }
 798
 799                 ctsduration += series[0].PktDuration;
 800
 801                 if ((bf->bf_flags & ATH9K_TXDESC_NOACK) == 0) { /* SIFS + ACK */
 802                         ctsduration += bf_isshpreamble(bf) ?
 803                                 rt->info[rix].spAckDuration :
 804                                 rt->info[rix].lpAckDuration;
 805                 }
 806
 807                 /*
 808                  * Disable multi-rate retry when using RTS/CTS by clearing
 809                  * series 1, 2 and 3.
 810                  */
 811                 memset(&series[1], 0, sizeof(struct ath9k_11n_rate_series) * 3);
 812         }
 813
 814         /*
 815          * set dur_update_en for l-sig computation except for PS-Poll frames
 816          */
 817         ath9k_hw_set11n_ratescenario(ah, ds, lastds,
 818                                      !bf_ispspoll(bf),
 819                                      ctsrate,
 820                                      ctsduration,
 821                                      series, 4, flags);
 822         if (sc->sc_config.ath_aggr_prot && flags)
 823                 ath9k_hw_set11n_burstduration(ah, ds, 8192);
 824 }
 825
 826 /*
 827  * Function to send a normal HT (non-AMPDU) frame
 828  * NB: must be called with txq lock held
 829  */
 830
 831 static int ath_tx_send_normal(struct ath_softc *sc,
 832                               struct ath_txq *txq,
 833                               struct ath_atx_tid *tid,
 834                               struct list_head *bf_head)
 835 {
 836         struct ath_buf *bf;
 837         struct sk_buff *skb;
 838         struct ieee80211_tx_info *tx_info;
 839         struct ath_tx_info_priv *tx_info_priv;
 840
 841         BUG_ON(list_empty(bf_head));
 842
 843         bf = list_first_entry(bf_head, struct ath_buf, list);
 844         bf->bf_state.bf_type &= ~BUF_AMPDU; /* regular HT frame */
 845
 846         skb = (struct sk_buff *)bf->bf_mpdu;
 847         tx_info = IEEE80211_SKB_CB(skb);
 848
 849         /* XXX: HACK! */
 850         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
 851         memcpy(bf->bf_rcs, tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
 852
 853         /* update starting sequence number for subsequent ADDBA request */
 854         INCR(tid->seq_start, IEEE80211_SEQ_MAX);
 855
 856         /* Queue to h/w without aggregation */
 857         bf->bf_nframes = 1;
 858         bf->bf_lastbf = bf->bf_lastfrm; /* one single frame */
 859         ath_buf_set_rate(sc, bf);
 860         ath_tx_txqaddbuf(sc, txq, bf_head);
 861
 862         return 0;
 863 }
 864
 865 /* flush tid's software queue and send frames as non-ampdu's */
 866
 867 static void ath_tx_flush_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
 868 {
 869         struct ath_txq *txq = &sc->sc_txq[tid->ac->qnum];
 870         struct ath_buf *bf;
 871         struct list_head bf_head;
 872         INIT_LIST_HEAD(&bf_head);
 873
 874         ASSERT(tid->paused > 0);
 875         spin_lock_bh(&txq->axq_lock);
 876
 877         tid->paused--;
 878
 879         if (tid->paused > 0) {
 880                 spin_unlock_bh(&txq->axq_lock);
 881                 return;
 882         }
 883
 884         while (!list_empty(&tid->buf_q)) {
 885                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
 886                 ASSERT(!bf_isretried(bf));
 887                 list_cut_position(&bf_head, &tid->buf_q, &bf->bf_lastfrm->list);
 888                 ath_tx_send_normal(sc, txq, tid, &bf_head);
 889         }
 890
 891         spin_unlock_bh(&txq->axq_lock);
 892 }
 893
 894 /* Completion routine of an aggregate */
 895
 896 static void ath_tx_complete_aggr_rifs(struct ath_softc *sc,
 897                                       struct ath_txq *txq,
 898                                       struct ath_buf *bf,
 899                                       struct list_head *bf_q,
 900                                       int txok)
 901 {
 902         struct ath_node *an = bf->bf_node;
 903         struct ath_atx_tid *tid = ATH_AN_2_TID(an, bf->bf_tidno);
 904         struct ath_buf *bf_last = bf->bf_lastbf;
 905         struct ath_desc *ds = bf_last->bf_desc;
 906         struct ath_buf *bf_next, *bf_lastq = NULL;
 907         struct list_head bf_head, bf_pending;
 908         u16 seq_st = 0;
 909         u32 ba[WME_BA_BMP_SIZE >> 5];
 910         int isaggr, txfail, txpending, sendbar = 0, needreset = 0;
 911         int isnodegone = (an->an_flags & ATH_NODE_CLEAN);
 912
 913         isaggr = bf_isaggr(bf);
 914         if (isaggr) {
 915                 if (txok) {
 916                         if (ATH_DS_TX_BA(ds)) {
 917                                 /*
 918                                  * extract starting sequence and
 919                                  * block-ack bitmap
 920                                  */
 921                                 seq_st = ATH_DS_BA_SEQ(ds);
 922                                 memcpy(ba,
 923                                         ATH_DS_BA_BITMAP(ds),
 924                                         WME_BA_BMP_SIZE >> 3);
 925                         } else {
 926                                 memset(ba, 0, WME_BA_BMP_SIZE >> 3);
 927
 928                                 /*
 929                                  * AR5416 can become deaf/mute when BA
 930                                  * issue happens. Chip needs to be reset.
 931                                  * But AP code may have sychronization issues
 932                                  * when perform internal reset in this routine.
 933                                  * Only enable reset in STA mode for now.
 934                                  */
 935                                 if (sc->sc_ah->ah_opmode == ATH9K_M_STA)
 936                                         needreset = 1;
 937                         }
 938                 } else {
 939                         memset(ba, 0, WME_BA_BMP_SIZE >> 3);
 940                 }
 941         }
 942
 943         INIT_LIST_HEAD(&bf_pending);
 944         INIT_LIST_HEAD(&bf_head);
 945
 946         while (bf) {
 947                 txfail = txpending = 0;
 948                 bf_next = bf->bf_next;
 949
 950                 if (ATH_BA_ISSET(ba, ATH_BA_INDEX(seq_st, bf->bf_seqno))) {
 951                         /* transmit completion, subframe is
 952                          * acked by block ack */
 953                 } else if (!isaggr && txok) {
 954                         /* transmit completion */
 955                 } else {
 956
 957                         if (!tid->cleanup_inprogress && !isnodegone &&
 958                             ds->ds_txstat.ts_flags != ATH9K_TX_SW_ABORTED) {
 959                                 if (bf->bf_retries < ATH_MAX_SW_RETRIES) {
 960                                         ath_tx_set_retry(sc, bf);
 961                                         txpending = 1;
 962                                 } else {
 963                                         bf->bf_state.bf_type |= BUF_XRETRY;
 964                                         txfail = 1;
 965                                         sendbar = 1;
 966                                 }
 967                         } else {
 968                                 /*
 969                                  * cleanup in progress, just fail
 970                                  * the un-acked sub-frames
 971                                  */
 972                                 txfail = 1;
 973                         }
 974                 }
 975                 /*
 976                  * Remove ath_buf's of this sub-frame from aggregate queue.
 977                  */
 978                 if (bf_next == NULL) {  /* last subframe in the aggregate */
 979                         ASSERT(bf->bf_lastfrm == bf_last);
 980
 981                         /*
 982                          * The last descriptor of the last sub frame could be
 983                          * a holding descriptor for h/w. If that's the case,
 984                          * bf->bf_lastfrm won't be in the bf_q.
 985                          * Make sure we handle bf_q properly here.
 986                          */
 987
 988                         if (!list_empty(bf_q)) {
 989                                 bf_lastq = list_entry(bf_q->prev,
 990                                         struct ath_buf, list);
 991                                 list_cut_position(&bf_head,
 992                                         bf_q, &bf_lastq->list);
 993                         } else {
 994                                 /*
 995                                  * XXX: if the last subframe only has one
 996                                  * descriptor which is also being used as
 997                                  * a holding descriptor. Then the ath_buf
 998                                  * is not in the bf_q at all.
 999                                  */
1000                                 INIT_LIST_HEAD(&bf_head);
1001                         }
1002                 } else {
1003                         ASSERT(!list_empty(bf_q));
1004                         list_cut_position(&bf_head,
1005                                 bf_q, &bf->bf_lastfrm->list);
1006                 }
1007
1008                 if (!txpending) {
1009                         /*
1010                          * complete the acked-ones/xretried ones; update
1011                          * block-ack window
1012                          */
1013                         spin_lock_bh(&txq->axq_lock);
1014                         ath_tx_update_baw(sc, tid, bf->bf_seqno);
1015                         spin_unlock_bh(&txq->axq_lock);
1016
1017                         /* complete this sub-frame */
1018                         ath_tx_complete_buf(sc, bf, &bf_head, !txfail, sendbar);
1019                 } else {
1020                         /*
1021                          * retry the un-acked ones
1022                          */
1023                         /*
1024                          * XXX: if the last descriptor is holding descriptor,
1025                          * in order to requeue the frame to software queue, we
1026                          * need to allocate a new descriptor and
1027                          * copy the content of holding descriptor to it.
1028                          */
1029                         if (bf->bf_next == NULL &&
1030                             bf_last->bf_status & ATH_BUFSTATUS_STALE) {
1031                                 struct ath_buf *tbf;
1032
1033                                 /* allocate new descriptor */
1034                                 spin_lock_bh(&sc->sc_txbuflock);
1035                                 ASSERT(!list_empty((&sc->sc_txbuf)));
1036                                 tbf = list_first_entry(&sc->sc_txbuf,
1037                                                 struct ath_buf, list);
1038                                 list_del(&tbf->list);
1039                                 spin_unlock_bh(&sc->sc_txbuflock);
1040
1041                                 ATH_TXBUF_RESET(tbf);
1042
1043                                 /* copy descriptor content */
1044                                 tbf->bf_mpdu = bf_last->bf_mpdu;
1045                                 tbf->bf_node = bf_last->bf_node;
1046                                 tbf->bf_buf_addr = bf_last->bf_buf_addr;
1047                                 *(tbf->bf_desc) = *(bf_last->bf_desc);
1048
1049                                 /* link it to the frame */
1050                                 if (bf_lastq) {
1051                                         bf_lastq->bf_desc->ds_link =
1052                                                 tbf->bf_daddr;
1053                                         bf->bf_lastfrm = tbf;
1054                                         ath9k_hw_cleartxdesc(sc->sc_ah,
1055                                                 bf->bf_lastfrm->bf_desc);
1056                                 } else {
1057                                         tbf->bf_state = bf_last->bf_state;
1058                                         tbf->bf_lastfrm = tbf;
1059                                         ath9k_hw_cleartxdesc(sc->sc_ah,
1060                                                 tbf->bf_lastfrm->bf_desc);
1061
1062                                         /* copy the DMA context */
1063                                         tbf->bf_dmacontext =
1064                                                 bf_last->bf_dmacontext;
1065                                 }
1066                                 list_add_tail(&tbf->list, &bf_head);
1067                         } else {
1068                                 /*
1069                                  * Clear descriptor status words for
1070                                  * software retry
1071                                  */
1072                                 ath9k_hw_cleartxdesc(sc->sc_ah,
1073                                                      bf->bf_lastfrm->bf_desc);
1074                         }
1075
1076                         /*
1077                          * Put this buffer to the temporary pending
1078                          * queue to retain ordering
1079                          */
1080                         list_splice_tail_init(&bf_head, &bf_pending);
1081                 }
1082
1083                 bf = bf_next;
1084         }
1085
1086         /*
1087          * node is already gone. no more assocication
1088          * with the node. the node might have been freed
1089          * any  node acces can result in panic.note tid
1090          * is part of the node.
1091          */
1092         if (isnodegone)
1093                 return;
1094
1095         if (tid->cleanup_inprogress) {
1096                 /* check to see if we're done with cleaning the h/w queue */
1097                 spin_lock_bh(&txq->axq_lock);
1098
1099                 if (tid->baw_head == tid->baw_tail) {
1100                         tid->addba_exchangecomplete = 0;
1101                         tid->addba_exchangeattempts = 0;
1102                         spin_unlock_bh(&txq->axq_lock);
1103
1104                         tid->cleanup_inprogress = false;
1105
1106                         /* send buffered frames as singles */
1107                         ath_tx_flush_tid(sc, tid);
1108                 } else
1109                         spin_unlock_bh(&txq->axq_lock);
1110
1111                 return;
1112         }
1113
1114         /*
1115          * prepend un-acked frames to the beginning of the pending frame queue
1116          */
1117         if (!list_empty(&bf_pending)) {
1118                 spin_lock_bh(&txq->axq_lock);
1119                 /* Note: we _prepend_, we _do_not_ at to
1120                  * the end of the queue ! */
1121                 list_splice(&bf_pending, &tid->buf_q);
1122                 ath_tx_queue_tid(txq, tid);
1123                 spin_unlock_bh(&txq->axq_lock);
1124         }
1125
1126         if (needreset)
1127                 ath_reset(sc, false);
1128
1129         return;
1130 }
1131
1132 /* Process completed xmit descriptors from the specified queue */
1133
1134 static int ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq)
1135 {
1136         struct ath_hal *ah = sc->sc_ah;
1137         struct ath_buf *bf, *lastbf, *bf_held = NULL;
1138         struct list_head bf_head;
1139         struct ath_desc *ds, *tmp_ds;
1140         struct sk_buff *skb;
1141         struct ieee80211_tx_info *tx_info;
1142         struct ath_tx_info_priv *tx_info_priv;
1143         int nacked, txok, nbad = 0, isrifs = 0;
1144         int status;
1145
1146         DPRINTF(sc, ATH_DBG_QUEUE,
1147                 "%s: tx queue %d (%x), link %p\n", __func__,
1148                 txq->axq_qnum, ath9k_hw_gettxbuf(sc->sc_ah, txq->axq_qnum),
1149                 txq->axq_link);
1150
1151         nacked = 0;
1152         for (;;) {
1153                 spin_lock_bh(&txq->axq_lock);
1154                 if (list_empty(&txq->axq_q)) {
1155                         txq->axq_link = NULL;
1156                         txq->axq_linkbuf = NULL;
1157                         spin_unlock_bh(&txq->axq_lock);
1158                         break;
1159                 }
1160                 bf = list_first_entry(&txq->axq_q, struct ath_buf, list);
1161
1162                 /*
1163                  * There is a race condition that a BH gets scheduled
1164                  * after sw writes TxE and before hw re-load the last
1165                  * descriptor to get the newly chained one.
1166                  * Software must keep the last DONE descriptor as a
1167                  * holding descriptor - software does so by marking
1168                  * it with the STALE flag.
1169                  */
1170                 bf_held = NULL;
1171                 if (bf->bf_status & ATH_BUFSTATUS_STALE) {
1172                         bf_held = bf;
1173                         if (list_is_last(&bf_held->list, &txq->axq_q)) {
1174                                 /* FIXME:
1175                                  * The holding descriptor is the last
1176                                  * descriptor in queue. It's safe to remove
1177                                  * the last holding descriptor in BH context.
1178                                  */
1179                                 spin_unlock_bh(&txq->axq_lock);
1180                                 break;
1181                         } else {
1182                                 /* Lets work with the next buffer now */
1183                                 bf = list_entry(bf_held->list.next,
1184                                         struct ath_buf, list);
1185                         }
1186                 }
1187
1188                 lastbf = bf->bf_lastbf;
1189                 ds = lastbf->bf_desc;    /* NB: last decriptor */
1190
1191                 status = ath9k_hw_txprocdesc(ah, ds);
1192                 if (status == -EINPROGRESS) {
1193                         spin_unlock_bh(&txq->axq_lock);
1194                         break;
1195                 }
1196                 if (bf->bf_desc == txq->axq_lastdsWithCTS)
1197                         txq->axq_lastdsWithCTS = NULL;
1198                 if (ds == txq->axq_gatingds)
1199                         txq->axq_gatingds = NULL;
1200
1201                 /*
1202                  * Remove ath_buf's of the same transmit unit from txq,
1203                  * however leave the last descriptor back as the holding
1204                  * descriptor for hw.
1205                  */
1206                 lastbf->bf_status |= ATH_BUFSTATUS_STALE;
1207                 INIT_LIST_HEAD(&bf_head);
1208
1209                 if (!list_is_singular(&lastbf->list))
1210                         list_cut_position(&bf_head,
1211                                 &txq->axq_q, lastbf->list.prev);
1212
1213                 txq->axq_depth--;
1214
1215                 if (bf_isaggr(bf))
1216                         txq->axq_aggr_depth--;
1217
1218                 txok = (ds->ds_txstat.ts_status == 0);
1219
1220                 spin_unlock_bh(&txq->axq_lock);
1221
1222                 if (bf_held) {
1223                         list_del(&bf_held->list);
1224                         spin_lock_bh(&sc->sc_txbuflock);
1225                         list_add_tail(&bf_held->list, &sc->sc_txbuf);
1226                         spin_unlock_bh(&sc->sc_txbuflock);
1227                 }
1228
1229                 if (!bf_isampdu(bf)) {
1230                         /*
1231                          * This frame is sent out as a single frame.
1232                          * Use hardware retry status for this frame.
1233                          */
1234                         bf->bf_retries = ds->ds_txstat.ts_longretry;
1235                         if (ds->ds_txstat.ts_status & ATH9K_TXERR_XRETRY)
1236                                 bf->bf_state.bf_type |= BUF_XRETRY;
1237                         nbad = 0;
1238                 } else {
1239                         nbad = ath_tx_num_badfrms(sc, bf, txok);
1240                 }
1241                 skb = bf->bf_mpdu;
1242                 tx_info = IEEE80211_SKB_CB(skb);
1243
1244                 /* XXX: HACK! */
1245                 tx_info_priv = (struct ath_tx_info_priv *) tx_info->control.vif;
1246                 if (ds->ds_txstat.ts_status & ATH9K_TXERR_FILT)
1247                         tx_info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
1248                 if ((ds->ds_txstat.ts_status & ATH9K_TXERR_FILT) == 0 &&
1249                                 (bf->bf_flags & ATH9K_TXDESC_NOACK) == 0) {
1250                         if (ds->ds_txstat.ts_status == 0)
1251                                 nacked++;
1252
1253                         if (bf_isdata(bf)) {
1254                                 if (isrifs)
1255                                         tmp_ds = bf->bf_rifslast->bf_desc;
1256                                 else
1257                                         tmp_ds = ds;
1258                                 memcpy(&tx_info_priv->tx,
1259                                         &tmp_ds->ds_txstat,
1260                                         sizeof(tx_info_priv->tx));
1261                                 tx_info_priv->n_frames = bf->bf_nframes;
1262                                 tx_info_priv->n_bad_frames = nbad;
1263                         }
1264                 }
1265
1266                 /*
1267                  * Complete this transmit unit
1268                  */
1269                 if (bf_isampdu(bf))
1270                         ath_tx_complete_aggr_rifs(sc, txq, bf, &bf_head, txok);
1271                 else
1272                         ath_tx_complete_buf(sc, bf, &bf_head, txok, 0);
1273
1274                 /* Wake up mac80211 queue */
1275
1276                 spin_lock_bh(&txq->axq_lock);
1277                 if (txq->stopped && ath_txq_depth(sc, txq->axq_qnum) <=
1278                                 (ATH_TXBUF - 20)) {
1279                         int qnum;
1280                         qnum = ath_get_mac80211_qnum(txq->axq_qnum, sc);
1281                         if (qnum != -1) {
1282                                 ieee80211_wake_queue(sc->hw, qnum);
1283                                 txq->stopped = 0;
1284                         }
1285
1286                 }
1287
1288                 /*
1289                  * schedule any pending packets if aggregation is enabled
1290                  */
1291                 if (sc->sc_flags & SC_OP_TXAGGR)
1292                         ath_txq_schedule(sc, txq);
1293                 spin_unlock_bh(&txq->axq_lock);
1294         }
1295         return nacked;
1296 }
1297
1298 static void ath_tx_stopdma(struct ath_softc *sc, struct ath_txq *txq)
1299 {
1300         struct ath_hal *ah = sc->sc_ah;
1301
1302         (void) ath9k_hw_stoptxdma(ah, txq->axq_qnum);
1303         DPRINTF(sc, ATH_DBG_XMIT, "%s: tx queue [%u] %x, link %p\n",
1304                 __func__, txq->axq_qnum,
1305                 ath9k_hw_gettxbuf(ah, txq->axq_qnum), txq->axq_link);
1306 }
1307
1308 /* Drain only the data queues */
1309
1310 static void ath_drain_txdataq(struct ath_softc *sc, bool retry_tx)
1311 {
1312         struct ath_hal *ah = sc->sc_ah;
1313         int i;
1314         int npend = 0;
1315
1316         /* XXX return value */
1317         if (!(sc->sc_flags & SC_OP_INVALID)) {
1318                 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1319                         if (ATH_TXQ_SETUP(sc, i)) {
1320                                 ath_tx_stopdma(sc, &sc->sc_txq[i]);
1321
1322                                 /* The TxDMA may not really be stopped.
1323                                  * Double check the hal tx pending count */
1324                                 npend += ath9k_hw_numtxpending(ah,
1325                                         sc->sc_txq[i].axq_qnum);
1326                         }
1327                 }
1328         }
1329
1330         if (npend) {
1331                 int status;
1332
1333                 /* TxDMA not stopped, reset the hal */
1334                 DPRINTF(sc, ATH_DBG_XMIT,
1335                         "%s: Unable to stop TxDMA. Reset HAL!\n", __func__);
1336
1337                 spin_lock_bh(&sc->sc_resetlock);
1338                 if (!ath9k_hw_reset(ah,
1339                                     sc->sc_ah->ah_curchan,
1340                                     sc->sc_ht_info.tx_chan_width,
1341                                     sc->sc_tx_chainmask, sc->sc_rx_chainmask,
1342                                     sc->sc_ht_extprotspacing, true, &status)) {
1343
1344                         DPRINTF(sc, ATH_DBG_FATAL,
1345                                 "%s: unable to reset hardware; hal status %u\n",
1346                                 __func__,
1347                                 status);
1348                 }
1349                 spin_unlock_bh(&sc->sc_resetlock);
1350         }
1351
1352         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1353                 if (ATH_TXQ_SETUP(sc, i))
1354                         ath_tx_draintxq(sc, &sc->sc_txq[i], retry_tx);
1355         }
1356 }
1357
1358 /* Add a sub-frame to block ack window */
1359
1360 static void ath_tx_addto_baw(struct ath_softc *sc,
1361                              struct ath_atx_tid *tid,
1362                              struct ath_buf *bf)
1363 {
1364         int index, cindex;
1365
1366         if (bf_isretried(bf))
1367                 return;
1368
1369         index  = ATH_BA_INDEX(tid->seq_start, bf->bf_seqno);
1370         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
1371
1372         ASSERT(tid->tx_buf[cindex] == NULL);
1373         tid->tx_buf[cindex] = bf;
1374
1375         if (index >= ((tid->baw_tail - tid->baw_head) &
1376                 (ATH_TID_MAX_BUFS - 1))) {
1377                 tid->baw_tail = cindex;
1378                 INCR(tid->baw_tail, ATH_TID_MAX_BUFS);
1379         }
1380 }
1381
1382 /*
1383  * Function to send an A-MPDU
1384  * NB: must be called with txq lock held
1385  */
1386
1387 static int ath_tx_send_ampdu(struct ath_softc *sc,
1388                              struct ath_txq *txq,
1389                              struct ath_atx_tid *tid,
1390                              struct list_head *bf_head,
1391                              struct ath_tx_control *txctl)
1392 {
1393         struct ath_buf *bf;
1394         struct sk_buff *skb;
1395         struct ieee80211_tx_info *tx_info;
1396         struct ath_tx_info_priv *tx_info_priv;
1397
1398         BUG_ON(list_empty(bf_head));
1399
1400         bf = list_first_entry(bf_head, struct ath_buf, list);
1401         bf->bf_state.bf_type |= BUF_AMPDU;
1402         bf->bf_seqno = txctl->seqno; /* save seqno and tidno in buffer */
1403         bf->bf_tidno = txctl->tidno;
1404
1405         /*
1406          * Do not queue to h/w when any of the following conditions is true:
1407          * - there are pending frames in software queue
1408          * - the TID is currently paused for ADDBA/BAR request
1409          * - seqno is not within block-ack window
1410          * - h/w queue depth exceeds low water mark
1411          */
1412         if (!list_empty(&tid->buf_q) || tid->paused ||
1413             !BAW_WITHIN(tid->seq_start, tid->baw_size, bf->bf_seqno) ||
1414             txq->axq_depth >= ATH_AGGR_MIN_QDEPTH) {
1415                 /*
1416                  * Add this frame to software queue for scheduling later
1417                  * for aggregation.
1418                  */
1419                 list_splice_tail_init(bf_head, &tid->buf_q);
1420                 ath_tx_queue_tid(txq, tid);
1421                 return 0;
1422         }
1423
1424         skb = (struct sk_buff *)bf->bf_mpdu;
1425         tx_info = IEEE80211_SKB_CB(skb);
1426         /* XXX: HACK! */
1427         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
1428         memcpy(bf->bf_rcs, tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
1429
1430         /* Add sub-frame to BAW */
1431         ath_tx_addto_baw(sc, tid, bf);
1432
1433         /* Queue to h/w without aggregation */
1434         bf->bf_nframes = 1;
1435         bf->bf_lastbf = bf->bf_lastfrm; /* one single frame */
1436         ath_buf_set_rate(sc, bf);
1437         ath_tx_txqaddbuf(sc, txq, bf_head);
1438         return 0;
1439 }
1440
1441 /*
1442  * looks up the rate
1443  * returns aggr limit based on lowest of the rates
1444  */
1445
1446 static u32 ath_lookup_rate(struct ath_softc *sc,
1447                            struct ath_buf *bf,
1448                            struct ath_atx_tid *tid)
1449 {
1450         const struct ath9k_rate_table *rt = sc->sc_currates;
1451         struct sk_buff *skb;
1452         struct ieee80211_tx_info *tx_info;
1453         struct ath_tx_info_priv *tx_info_priv;
1454         u32 max_4ms_framelen, frame_length;
1455         u16 aggr_limit, legacy = 0, maxampdu;
1456         int i;
1457
1458
1459         skb = (struct sk_buff *)bf->bf_mpdu;
1460         tx_info = IEEE80211_SKB_CB(skb);
1461         tx_info_priv = (struct ath_tx_info_priv *)
1462                 tx_info->control.vif; /* XXX: HACK! */
1463         memcpy(bf->bf_rcs,
1464                 tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
1465
1466         /*
1467          * Find the lowest frame length among the rate series that will have a
1468          * 4ms transmit duration.
1469          * TODO - TXOP limit needs to be considered.
1470          */
1471         max_4ms_framelen = ATH_AMPDU_LIMIT_MAX;
1472
1473         for (i = 0; i < 4; i++) {
1474                 if (bf->bf_rcs[i].tries) {
1475                         frame_length = bf->bf_rcs[i].max_4ms_framelen;
1476
1477                         if (rt->info[bf->bf_rcs[i].rix].phy != PHY_HT) {
1478                                 legacy = 1;
1479                                 break;
1480                         }
1481
1482                         max_4ms_framelen = min(max_4ms_framelen, frame_length);
1483                 }
1484         }
1485
1486         /*
1487          * limit aggregate size by the minimum rate if rate selected is
1488          * not a probe rate, if rate selected is a probe rate then
1489          * avoid aggregation of this packet.
1490          */
1491         if (tx_info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE || legacy)
1492                 return 0;
1493
1494         aggr_limit = min(max_4ms_framelen,
1495                 (u32)ATH_AMPDU_LIMIT_DEFAULT);
1496
1497         /*
1498          * h/w can accept aggregates upto 16 bit lengths (65535).
1499          * The IE, however can hold upto 65536, which shows up here
1500          * as zero. Ignore 65536 since we  are constrained by hw.
1501          */
1502         maxampdu = tid->an->maxampdu;
1503         if (maxampdu)
1504                 aggr_limit = min(aggr_limit, maxampdu);
1505
1506         return aggr_limit;
1507 }
1508
1509 /*
1510  * returns the number of delimiters to be added to
1511  * meet the minimum required mpdudensity.
1512  * caller should make sure that the rate is  HT rate .
1513  */
1514
1515 static int ath_compute_num_delims(struct ath_softc *sc,
1516                                   struct ath_atx_tid *tid,
1517                                   struct ath_buf *bf,
1518                                   u16 frmlen)
1519 {
1520         const struct ath9k_rate_table *rt = sc->sc_currates;
1521         u32 nsymbits, nsymbols, mpdudensity;
1522         u16 minlen;
1523         u8 rc, flags, rix;
1524         int width, half_gi, ndelim, mindelim;
1525
1526         /* Select standard number of delimiters based on frame length alone */
1527         ndelim = ATH_AGGR_GET_NDELIM(frmlen);
1528
1529         /*
1530          * If encryption enabled, hardware requires some more padding between
1531          * subframes.
1532          * TODO - this could be improved to be dependent on the rate.
1533          *      The hardware can keep up at lower rates, but not higher rates
1534          */
1535         if (bf->bf_keytype != ATH9K_KEY_TYPE_CLEAR)
1536                 ndelim += ATH_AGGR_ENCRYPTDELIM;
1537
1538         /*
1539          * Convert desired mpdu density from microeconds to bytes based
1540          * on highest rate in rate series (i.e. first rate) to determine
1541          * required minimum length for subframe. Take into account
1542          * whether high rate is 20 or 40Mhz and half or full GI.
1543          */
1544         mpdudensity = tid->an->mpdudensity;
1545
1546         /*
1547          * If there is no mpdu density restriction, no further calculation
1548          * is needed.
1549          */
1550         if (mpdudensity == 0)
1551                 return ndelim;
1552
1553         rix = bf->bf_rcs[0].rix;
1554         flags = bf->bf_rcs[0].flags;
1555         rc = rt->info[rix].rateCode;
1556         width = (flags & ATH_RC_CW40_FLAG) ? 1 : 0;
1557         half_gi = (flags & ATH_RC_SGI_FLAG) ? 1 : 0;
1558
1559         if (half_gi)
1560                 nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity);
1561         else
1562                 nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity);
1563
1564         if (nsymbols == 0)
1565                 nsymbols = 1;
1566
1567         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
1568         minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;
1569
1570         /* Is frame shorter than required minimum length? */
1571         if (frmlen < minlen) {
1572                 /* Get the minimum number of delimiters required. */
1573                 mindelim = (minlen - frmlen) / ATH_AGGR_DELIM_SZ;
1574                 ndelim = max(mindelim, ndelim);
1575         }
1576
1577         return ndelim;
1578 }
1579
1580 /*
1581  * For aggregation from software buffer queue.
1582  * NB: must be called with txq lock held
1583  */
1584
1585 static enum ATH_AGGR_STATUS ath_tx_form_aggr(struct ath_softc *sc,
1586                                         struct ath_atx_tid *tid,
1587                                         struct list_head *bf_q,
1588                                         struct ath_buf **bf_last,
1589                                         struct aggr_rifs_param *param,
1590                                         int *prev_frames)
1591 {
1592 #define PADBYTES(_len) ((4 - ((_len) % 4)) % 4)
1593         struct ath_buf *bf, *tbf, *bf_first, *bf_prev = NULL;
1594         struct list_head bf_head;
1595         int rl = 0, nframes = 0, ndelim;
1596         u16 aggr_limit = 0, al = 0, bpad = 0,
1597                 al_delta, h_baw = tid->baw_size / 2;
1598         enum ATH_AGGR_STATUS status = ATH_AGGR_DONE;
1599         int prev_al = 0, is_ds_rate = 0;
1600         INIT_LIST_HEAD(&bf_head);
1601
1602         BUG_ON(list_empty(&tid->buf_q));
1603
1604         bf_first = list_first_entry(&tid->buf_q, struct ath_buf, list);
1605
1606         do {
1607                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
1608
1609                 /*
1610                  * do not step over block-ack window
1611                  */
1612                 if (!BAW_WITHIN(tid->seq_start, tid->baw_size, bf->bf_seqno)) {
1613                         status = ATH_AGGR_BAW_CLOSED;
1614                         break;
1615                 }
1616
1617                 if (!rl) {
1618                         aggr_limit = ath_lookup_rate(sc, bf, tid);
1619                         rl = 1;
1620                         /*
1621                          * Is rate dual stream
1622                          */
1623                         is_ds_rate =
1624                                 (bf->bf_rcs[0].flags & ATH_RC_DS_FLAG) ? 1 : 0;
1625                 }
1626
1627                 /*
1628                  * do not exceed aggregation limit
1629                  */
1630                 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_frmlen;
1631
1632                 if (nframes && (aggr_limit <
1633                         (al + bpad + al_delta + prev_al))) {
1634                         status = ATH_AGGR_LIMITED;
1635                         break;
1636                 }
1637
1638                 /*
1639                  * do not exceed subframe limit
1640                  */
1641                 if ((nframes + *prev_frames) >=
1642                     min((int)h_baw, ATH_AMPDU_SUBFRAME_DEFAULT)) {
1643                         status = ATH_AGGR_LIMITED;
1644                         break;
1645                 }
1646
1647                 /*
1648                  * add padding for previous frame to aggregation length
1649                  */
1650                 al += bpad + al_delta;
1651
1652                 /*
1653                  * Get the delimiters needed to meet the MPDU
1654                  * density for this node.
1655                  */
1656                 ndelim = ath_compute_num_delims(sc, tid, bf_first, bf->bf_frmlen);
1657
1658                 bpad = PADBYTES(al_delta) + (ndelim << 2);
1659
1660                 bf->bf_next = NULL;
1661                 bf->bf_lastfrm->bf_desc->ds_link = 0;
1662
1663                 /*
1664                  * this packet is part of an aggregate
1665                  * - remove all descriptors belonging to this frame from
1666                  *   software queue
1667                  * - add it to block ack window
1668                  * - set up descriptors for aggregation
1669                  */
1670                 list_cut_position(&bf_head, &tid->buf_q, &bf->bf_lastfrm->list);
1671                 ath_tx_addto_baw(sc, tid, bf);
1672
1673                 list_for_each_entry(tbf, &bf_head, list) {
1674                         ath9k_hw_set11n_aggr_middle(sc->sc_ah,
1675                                 tbf->bf_desc, ndelim);
1676                 }
1677
1678                 /*
1679                  * link buffers of this frame to the aggregate
1680                  */
1681                 list_splice_tail_init(&bf_head, bf_q);
1682                 nframes++;
1683
1684                 if (bf_prev) {
1685                         bf_prev->bf_next = bf;
1686                         bf_prev->bf_lastfrm->bf_desc->ds_link = bf->bf_daddr;
1687                 }
1688                 bf_prev = bf;
1689
1690 #ifdef AGGR_NOSHORT
1691                 /*
1692                  * terminate aggregation on a small packet boundary
1693                  */
1694                 if (bf->bf_frmlen < ATH_AGGR_MINPLEN) {
1695                         status = ATH_AGGR_SHORTPKT;
1696                         break;
1697                 }
1698 #endif
1699         } while (!list_empty(&tid->buf_q));
1700
1701         bf_first->bf_al = al;
1702         bf_first->bf_nframes = nframes;
1703         *bf_last = bf_prev;
1704         return status;
1705 #undef PADBYTES
1706 }
1707
1708 /*
1709  * process pending frames possibly doing a-mpdu aggregation
1710  * NB: must be called with txq lock held
1711  */
1712
1713 static void ath_tx_sched_aggr(struct ath_softc *sc,
1714         struct ath_txq *txq, struct ath_atx_tid *tid)
1715 {
1716         struct ath_buf *bf, *tbf, *bf_last, *bf_lastaggr = NULL;
1717         enum ATH_AGGR_STATUS status;
1718         struct list_head bf_q;
1719         struct aggr_rifs_param param = {0, 0, 0, 0, NULL};
1720         int prev_frames = 0;
1721
1722         do {
1723                 if (list_empty(&tid->buf_q))
1724                         return;
1725
1726                 INIT_LIST_HEAD(&bf_q);
1727
1728                 status = ath_tx_form_aggr(sc, tid, &bf_q, &bf_lastaggr, &param,
1729                                           &prev_frames);
1730
1731                 /*
1732                  * no frames picked up to be aggregated; block-ack
1733                  * window is not open
1734                  */
1735                 if (list_empty(&bf_q))
1736                         break;
1737
1738                 bf = list_first_entry(&bf_q, struct ath_buf, list);
1739                 bf_last = list_entry(bf_q.prev, struct ath_buf, list);
1740                 bf->bf_lastbf = bf_last;
1741
1742                 /*
1743                  * if only one frame, send as non-aggregate
1744                  */
1745                 if (bf->bf_nframes == 1) {
1746                         ASSERT(bf->bf_lastfrm == bf_last);
1747
1748                         bf->bf_state.bf_type &= ~BUF_AGGR;
1749                         /*
1750                          * clear aggr bits for every descriptor
1751                          * XXX TODO: is there a way to optimize it?
1752                          */
1753                         list_for_each_entry(tbf, &bf_q, list) {
1754                                 ath9k_hw_clr11n_aggr(sc->sc_ah, tbf->bf_desc);
1755                         }
1756
1757                         ath_buf_set_rate(sc, bf);
1758                         ath_tx_txqaddbuf(sc, txq, &bf_q);
1759                         continue;
1760                 }
1761
1762                 /*
1763                  * setup first desc with rate and aggr info
1764                  */
1765                 bf->bf_state.bf_type |= BUF_AGGR;
1766                 ath_buf_set_rate(sc, bf);
1767                 ath9k_hw_set11n_aggr_first(sc->sc_ah, bf->bf_desc, bf->bf_al);
1768
1769                 /*
1770                  * anchor last frame of aggregate correctly
1771                  */
1772                 ASSERT(bf_lastaggr);
1773                 ASSERT(bf_lastaggr->bf_lastfrm == bf_last);
1774                 tbf = bf_lastaggr;
1775                 ath9k_hw_set11n_aggr_last(sc->sc_ah, tbf->bf_desc);
1776
1777                 /* XXX: We don't enter into this loop, consider removing this */
1778                 while (!list_empty(&bf_q) && !list_is_last(&tbf->list, &bf_q)) {
1779                         tbf = list_entry(tbf->list.next, struct ath_buf, list);
1780                         ath9k_hw_set11n_aggr_last(sc->sc_ah, tbf->bf_desc);
1781                 }
1782
1783                 txq->axq_aggr_depth++;
1784
1785                 /*
1786                  * Normal aggregate, queue to hardware
1787                  */
1788                 ath_tx_txqaddbuf(sc, txq, &bf_q);
1789
1790         } while (txq->axq_depth < ATH_AGGR_MIN_QDEPTH &&
1791                  status != ATH_AGGR_BAW_CLOSED);
1792 }
1793
1794 /* Called with txq lock held */
1795
1796 static void ath_tid_drain(struct ath_softc *sc,
1797                           struct ath_txq *txq,
1798                           struct ath_atx_tid *tid,
1799                           bool bh_flag)
1800 {
1801         struct ath_buf *bf;
1802         struct list_head bf_head;
1803         INIT_LIST_HEAD(&bf_head);
1804
1805         for (;;) {
1806                 if (list_empty(&tid->buf_q))
1807                         break;
1808                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
1809
1810                 list_cut_position(&bf_head, &tid->buf_q, &bf->bf_lastfrm->list);
1811
1812                 /* update baw for software retried frame */
1813                 if (bf_isretried(bf))
1814                         ath_tx_update_baw(sc, tid, bf->bf_seqno);
1815
1816                 /*
1817                  * do not indicate packets while holding txq spinlock.
1818                  * unlock is intentional here
1819                  */
1820                 if (likely(bh_flag))
1821                         spin_unlock_bh(&txq->axq_lock);
1822                 else
1823                         spin_unlock(&txq->axq_lock);
1824
1825                 /* complete this sub-frame */
1826                 ath_tx_complete_buf(sc, bf, &bf_head, 0, 0);
1827
1828                 if (likely(bh_flag))
1829                         spin_lock_bh(&txq->axq_lock);
1830                 else
1831                         spin_lock(&txq->axq_lock);
1832         }
1833
1834         /*
1835          * TODO: For frame(s) that are in the retry state, we will reuse the
1836          * sequence number(s) without setting the retry bit. The
1837          * alternative is to give up on these and BAR the receiver's window
1838          * forward.
1839          */
1840         tid->seq_next = tid->seq_start;
1841         tid->baw_tail = tid->baw_head;
1842 }
1843
1844 /*
1845  * Drain all pending buffers
1846  * NB: must be called with txq lock held
1847  */
1848
1849 static void ath_txq_drain_pending_buffers(struct ath_softc *sc,
1850                                           struct ath_txq *txq,
1851                                           bool bh_flag)
1852 {
1853         struct ath_atx_ac *ac, *ac_tmp;
1854         struct ath_atx_tid *tid, *tid_tmp;
1855
1856         list_for_each_entry_safe(ac, ac_tmp, &txq->axq_acq, list) {
1857                 list_del(&ac->list);
1858                 ac->sched = false;
1859                 list_for_each_entry_safe(tid, tid_tmp, &ac->tid_q, list) {
1860                         list_del(&tid->list);
1861                         tid->sched = false;
1862                         ath_tid_drain(sc, txq, tid, bh_flag);
1863                 }
1864         }
1865 }
1866
1867 static int ath_tx_start_dma(struct ath_softc *sc,
1868                             struct sk_buff *skb,
1869                             struct scatterlist *sg,
1870                             u32 n_sg,
1871                             struct ath_tx_control *txctl)
1872 {
1873         struct ath_node *an = txctl->an;
1874         struct ath_buf *bf = NULL;
1875         struct list_head bf_head;
1876         struct ath_desc *ds;
1877         struct ath_hal *ah = sc->sc_ah;
1878         struct ath_txq *txq;
1879         struct ath_tx_info_priv *tx_info_priv;
1880         struct ath_rc_series *rcs;
1881         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1882         struct ieee80211_tx_info *tx_info =  IEEE80211_SKB_CB(skb);
1883         __le16 fc = hdr->frame_control;
1884
1885         if (unlikely(txctl->flags & ATH9K_TXDESC_CAB))
1886                 txq = sc->sc_cabq;
1887         else
1888                 txq = &sc->sc_txq[txctl->qnum];
1889
1890         /* For each sglist entry, allocate an ath_buf for DMA */
1891         INIT_LIST_HEAD(&bf_head);
1892         spin_lock_bh(&sc->sc_txbuflock);
1893         if (unlikely(list_empty(&sc->sc_txbuf))) {
1894                 spin_unlock_bh(&sc->sc_txbuflock);
1895                 return -ENOMEM;
1896         }
1897
1898         bf = list_first_entry(&sc->sc_txbuf, struct ath_buf, list);
1899         list_del(&bf->list);
1900         spin_unlock_bh(&sc->sc_txbuflock);
1901
1902         list_add_tail(&bf->list, &bf_head);
1903
1904         /* set up this buffer */
1905         ATH_TXBUF_RESET(bf);
1906         bf->bf_frmlen = txctl->frmlen;
1907
1908         ieee80211_is_data(fc) ?
1909                 (bf->bf_state.bf_type |= BUF_DATA) :
1910                 (bf->bf_state.bf_type &= ~BUF_DATA);
1911         ieee80211_is_back_req(fc) ?
1912                 (bf->bf_state.bf_type |= BUF_BAR) :
1913                 (bf->bf_state.bf_type &= ~BUF_BAR);
1914         ieee80211_is_pspoll(fc) ?
1915                 (bf->bf_state.bf_type |= BUF_PSPOLL) :
1916                 (bf->bf_state.bf_type &= ~BUF_PSPOLL);
1917         (sc->sc_flags & SC_OP_PREAMBLE_SHORT) ?
1918                 (bf->bf_state.bf_type |= BUF_SHORT_PREAMBLE) :
1919                 (bf->bf_state.bf_type &= ~BUF_SHORT_PREAMBLE);
1920
1921         bf->bf_flags = txctl->flags;
1922         bf->bf_keytype = txctl->keytype;
1923         /* XXX: HACK! */
1924         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
1925         rcs = tx_info_priv->rcs;
1926         bf->bf_rcs[0] = rcs[0];
1927         bf->bf_rcs[1] = rcs[1];
1928         bf->bf_rcs[2] = rcs[2];
1929         bf->bf_rcs[3] = rcs[3];
1930         bf->bf_node = an;
1931         bf->bf_mpdu = skb;
1932         bf->bf_buf_addr = sg_dma_address(sg);
1933
1934         /* setup descriptor */
1935         ds = bf->bf_desc;
1936         ds->ds_link = 0;
1937         ds->ds_data = bf->bf_buf_addr;
1938
1939         /*
1940          * Save the DMA context in the first ath_buf
1941          */
1942         bf->bf_dmacontext = txctl->dmacontext;
1943
1944         /*
1945          * Formulate first tx descriptor with tx controls.
1946          */
1947         ath9k_hw_set11n_txdesc(ah,
1948                                ds,
1949                                bf->bf_frmlen, /* frame length */
1950                                txctl->atype, /* Atheros packet type */
1951                                min(txctl->txpower, (u16)60), /* txpower */
1952                                txctl->keyix,            /* key cache index */
1953                                txctl->keytype,          /* key type */
1954                                txctl->flags);           /* flags */
1955         ath9k_hw_filltxdesc(ah,
1956                             ds,
1957                             sg_dma_len(sg),     /* segment length */
1958                             true,            /* first segment */
1959                             (n_sg == 1) ? true : false, /* last segment */
1960                             ds);                /* first descriptor */
1961
1962         bf->bf_lastfrm = bf;
1963         (txctl->ht) ?
1964                 (bf->bf_state.bf_type |= BUF_HT) :
1965                 (bf->bf_state.bf_type &= ~BUF_HT);
1966
1967         spin_lock_bh(&txq->axq_lock);
1968
1969         if (txctl->ht && (sc->sc_flags & SC_OP_TXAGGR)) {
1970                 struct ath_atx_tid *tid = ATH_AN_2_TID(an, txctl->tidno);
1971                 if (ath_aggr_query(sc, an, txctl->tidno)) {
1972                         /*
1973                          * Try aggregation if it's a unicast data frame
1974                          * and the destination is HT capable.
1975                          */
1976                         ath_tx_send_ampdu(sc, txq, tid, &bf_head, txctl);
1977                 } else {
1978                         /*
1979                          * Send this frame as regular when ADDBA exchange
1980                          * is neither complete nor pending.
1981                          */
1982                         ath_tx_send_normal(sc, txq, tid, &bf_head);
1983                 }
1984         } else {
1985                 bf->bf_lastbf = bf;
1986                 bf->bf_nframes = 1;
1987                 ath_buf_set_rate(sc, bf);
1988
1989                 if (ieee80211_is_back_req(fc)) {
1990                         /* This is required for resuming tid
1991                          * during BAR completion */
1992                         bf->bf_tidno = txctl->tidno;
1993                 }
1994
1995                 ath_tx_txqaddbuf(sc, txq, &bf_head);
1996         }
1997         spin_unlock_bh(&txq->axq_lock);
1998         return 0;
1999 }
2000
2001 static void xmit_map_sg(struct ath_softc *sc,
2002                         struct sk_buff *skb,
2003                         struct ath_tx_control *txctl)
2004 {
2005         struct ath_xmit_status tx_status;
2006         struct ath_atx_tid *tid;
2007         struct scatterlist sg;
2008
2009         txctl->dmacontext = pci_map_single(sc->pdev, skb->data,
2010                                            skb->len, PCI_DMA_TODEVICE);
2011
2012         /* setup S/G list */
2013         memset(&sg, 0, sizeof(struct scatterlist));
2014         sg_dma_address(&sg) = txctl->dmacontext;
2015         sg_dma_len(&sg) = skb->len;
2016
2017         if (ath_tx_start_dma(sc, skb, &sg, 1, txctl) != 0) {
2018                 /*
2019                  *  We have to do drop frame here.
2020                  */
2021                 pci_unmap_single(sc->pdev, txctl->dmacontext,
2022                                  skb->len, PCI_DMA_TODEVICE);
2023
2024                 tx_status.retries = 0;
2025                 tx_status.flags = ATH_TX_ERROR;
2026
2027                 if (txctl->ht && (sc->sc_flags & SC_OP_TXAGGR)) {
2028                         /* Reclaim the seqno. */
2029                         tid = ATH_AN_2_TID((struct ath_node *)
2030                                 txctl->an, txctl->tidno);
2031                         DECR(tid->seq_next, IEEE80211_SEQ_MAX);
2032                 }
2033                 ath_tx_complete(sc, skb, &tx_status, txctl->an);
2034         }
2035 }
2036
2037 /* Initialize TX queue and h/w */
2038
2039 int ath_tx_init(struct ath_softc *sc, int nbufs)
2040 {
2041         int error = 0;
2042
2043         do {
2044                 spin_lock_init(&sc->sc_txbuflock);
2045
2046                 /* Setup tx descriptors */
2047                 error = ath_descdma_setup(sc, &sc->sc_txdma, &sc->sc_txbuf,
2048                         "tx", nbufs, 1);
2049                 if (error != 0) {
2050                         DPRINTF(sc, ATH_DBG_FATAL,
2051                                 "%s: failed to allocate tx descriptors: %d\n",
2052                                 __func__, error);
2053                         break;
2054                 }
2055
2056                 /* XXX allocate beacon state together with vap */
2057                 error = ath_descdma_setup(sc, &sc->sc_bdma, &sc->sc_bbuf,
2058                                           "beacon", ATH_BCBUF, 1);
2059                 if (error != 0) {
2060                         DPRINTF(sc, ATH_DBG_FATAL,
2061                                 "%s: failed to allocate "
2062                                 "beacon descripotrs: %d\n",
2063                                 __func__, error);
2064                         break;
2065                 }
2066
2067         } while (0);
2068
2069         if (error != 0)
2070                 ath_tx_cleanup(sc);
2071
2072         return error;
2073 }
2074
2075 /* Reclaim all tx queue resources */
2076
2077 int ath_tx_cleanup(struct ath_softc *sc)
2078 {
2079         /* cleanup beacon descriptors */
2080         if (sc->sc_bdma.dd_desc_len != 0)
2081                 ath_descdma_cleanup(sc, &sc->sc_bdma, &sc->sc_bbuf);
2082
2083         /* cleanup tx descriptors */
2084         if (sc->sc_txdma.dd_desc_len != 0)
2085                 ath_descdma_cleanup(sc, &sc->sc_txdma, &sc->sc_txbuf);
2086
2087         return 0;
2088 }
2089
2090 /* Setup a h/w transmit queue */
2091
2092 struct ath_txq *ath_txq_setup(struct ath_softc *sc, int qtype, int subtype)
2093 {
2094         struct ath_hal *ah = sc->sc_ah;
2095         struct ath9k_tx_queue_info qi;
2096         int qnum;
2097
2098         memset(&qi, 0, sizeof(qi));
2099         qi.tqi_subtype = subtype;
2100         qi.tqi_aifs = ATH9K_TXQ_USEDEFAULT;
2101         qi.tqi_cwmin = ATH9K_TXQ_USEDEFAULT;
2102         qi.tqi_cwmax = ATH9K_TXQ_USEDEFAULT;
2103         qi.tqi_physCompBuf = 0;
2104
2105         /*
2106          * Enable interrupts only for EOL and DESC conditions.
2107          * We mark tx descriptors to receive a DESC interrupt
2108          * when a tx queue gets deep; otherwise waiting for the
2109          * EOL to reap descriptors.  Note that this is done to
2110          * reduce interrupt load and this only defers reaping
2111          * descriptors, never transmitting frames.  Aside from
2112          * reducing interrupts this also permits more concurrency.
2113          * The only potential downside is if the tx queue backs
2114          * up in which case the top half of the kernel may backup
2115          * due to a lack of tx descriptors.
2116          *
2117          * The UAPSD queue is an exception, since we take a desc-
2118          * based intr on the EOSP frames.
2119          */
2120         if (qtype == ATH9K_TX_QUEUE_UAPSD)
2121                 qi.tqi_qflags = TXQ_FLAG_TXDESCINT_ENABLE;
2122         else
2123                 qi.tqi_qflags = TXQ_FLAG_TXEOLINT_ENABLE |
2124                         TXQ_FLAG_TXDESCINT_ENABLE;
2125         qnum = ath9k_hw_setuptxqueue(ah, qtype, &qi);
2126         if (qnum == -1) {
2127                 /*
2128                  * NB: don't print a message, this happens
2129                  * normally on parts with too few tx queues
2130                  */
2131                 return NULL;
2132         }
2133         if (qnum >= ARRAY_SIZE(sc->sc_txq)) {
2134                 DPRINTF(sc, ATH_DBG_FATAL,
2135                         "%s: hal qnum %u out of range, max %u!\n",
2136                         __func__, qnum, (unsigned int)ARRAY_SIZE(sc->sc_txq));
2137                 ath9k_hw_releasetxqueue(ah, qnum);
2138                 return NULL;
2139         }
2140         if (!ATH_TXQ_SETUP(sc, qnum)) {
2141                 struct ath_txq *txq = &sc->sc_txq[qnum];
2142
2143                 txq->axq_qnum = qnum;
2144                 txq->axq_link = NULL;
2145                 INIT_LIST_HEAD(&txq->axq_q);
2146                 INIT_LIST_HEAD(&txq->axq_acq);
2147                 spin_lock_init(&txq->axq_lock);
2148                 txq->axq_depth = 0;
2149                 txq->axq_aggr_depth = 0;
2150                 txq->axq_totalqueued = 0;
2151                 txq->axq_linkbuf = NULL;
2152                 sc->sc_txqsetup |= 1<<qnum;
2153         }
2154         return &sc->sc_txq[qnum];
2155 }
2156
2157 /* Reclaim resources for a setup queue */
2158
2159 void ath_tx_cleanupq(struct ath_softc *sc, struct ath_txq *txq)
2160 {
2161         ath9k_hw_releasetxqueue(sc->sc_ah, txq->axq_qnum);
2162         sc->sc_txqsetup &= ~(1<<txq->axq_qnum);
2163 }
2164
2165 /*
2166  * Setup a hardware data transmit queue for the specified
2167  * access control.  The hal may not support all requested
2168  * queues in which case it will return a reference to a
2169  * previously setup queue.  We record the mapping from ac's
2170  * to h/w queues for use by ath_tx_start and also track
2171  * the set of h/w queues being used to optimize work in the
2172  * transmit interrupt handler and related routines.
2173  */
2174
2175 int ath_tx_setup(struct ath_softc *sc, int haltype)
2176 {
2177         struct ath_txq *txq;
2178
2179         if (haltype >= ARRAY_SIZE(sc->sc_haltype2q)) {
2180                 DPRINTF(sc, ATH_DBG_FATAL,
2181                         "%s: HAL AC %u out of range, max %zu!\n",
2182                         __func__, haltype, ARRAY_SIZE(sc->sc_haltype2q));
2183                 return 0;
2184         }
2185         txq = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, haltype);
2186         if (txq != NULL) {
2187                 sc->sc_haltype2q[haltype] = txq->axq_qnum;
2188                 return 1;
2189         } else
2190                 return 0;
2191 }
2192
2193 int ath_tx_get_qnum(struct ath_softc *sc, int qtype, int haltype)
2194 {
2195         int qnum;
2196
2197         switch (qtype) {
2198         case ATH9K_TX_QUEUE_DATA:
2199                 if (haltype >= ARRAY_SIZE(sc->sc_haltype2q)) {
2200                         DPRINTF(sc, ATH_DBG_FATAL,
2201                                 "%s: HAL AC %u out of range, max %zu!\n",
2202                                 __func__,
2203                                 haltype, ARRAY_SIZE(sc->sc_haltype2q));
2204                         return -1;
2205                 }
2206                 qnum = sc->sc_haltype2q[haltype];
2207                 break;
2208         case ATH9K_TX_QUEUE_BEACON:
2209                 qnum = sc->sc_bhalq;
2210                 break;
2211         case ATH9K_TX_QUEUE_CAB:
2212                 qnum = sc->sc_cabq->axq_qnum;
2213                 break;
2214         default:
2215                 qnum = -1;
2216         }
2217         return qnum;
2218 }
2219
2220 /* Update parameters for a transmit queue */
2221
2222 int ath_txq_update(struct ath_softc *sc, int qnum,
2223                    struct ath9k_tx_queue_info *qinfo)
2224 {
2225         struct ath_hal *ah = sc->sc_ah;
2226         int error = 0;
2227         struct ath9k_tx_queue_info qi;
2228
2229         if (qnum == sc->sc_bhalq) {
2230                 /*
2231                  * XXX: for beacon queue, we just save the parameter.
2232                  * It will be picked up by ath_beaconq_config when
2233                  * it's necessary.
2234                  */
2235                 sc->sc_beacon_qi = *qinfo;
2236                 return 0;
2237         }
2238
2239         ASSERT(sc->sc_txq[qnum].axq_qnum == qnum);
2240
2241         ath9k_hw_get_txq_props(ah, qnum, &qi);
2242         qi.tqi_aifs = qinfo->tqi_aifs;
2243         qi.tqi_cwmin = qinfo->tqi_cwmin;
2244         qi.tqi_cwmax = qinfo->tqi_cwmax;
2245         qi.tqi_burstTime = qinfo->tqi_burstTime;
2246         qi.tqi_readyTime = qinfo->tqi_readyTime;
2247
2248         if (!ath9k_hw_set_txq_props(ah, qnum, &qi)) {
2249                 DPRINTF(sc, ATH_DBG_FATAL,
2250                         "%s: unable to update hardware queue %u!\n",
2251                         __func__, qnum);
2252                 error = -EIO;
2253         } else {
2254                 ath9k_hw_resettxqueue(ah, qnum); /* push to h/w */
2255         }
2256
2257         return error;
2258 }
2259
2260 int ath_cabq_update(struct ath_softc *sc)
2261 {
2262         struct ath9k_tx_queue_info qi;
2263         int qnum = sc->sc_cabq->axq_qnum;
2264         struct ath_beacon_config conf;
2265
2266         ath9k_hw_get_txq_props(sc->sc_ah, qnum, &qi);
2267         /*
2268          * Ensure the readytime % is within the bounds.
2269          */
2270         if (sc->sc_config.cabqReadytime < ATH9K_READY_TIME_LO_BOUND)
2271                 sc->sc_config.cabqReadytime = ATH9K_READY_TIME_LO_BOUND;
2272         else if (sc->sc_config.cabqReadytime > ATH9K_READY_TIME_HI_BOUND)
2273                 sc->sc_config.cabqReadytime = ATH9K_READY_TIME_HI_BOUND;
2274
2275         ath_get_beaconconfig(sc, ATH_IF_ID_ANY, &conf);
2276         qi.tqi_readyTime =
2277                 (conf.beacon_interval * sc->sc_config.cabqReadytime) / 100;
2278         ath_txq_update(sc, qnum, &qi);
2279
2280         return 0;
2281 }
2282
2283 int ath_tx_start(struct ath_softc *sc, struct sk_buff *skb)
2284 {
2285         struct ath_tx_control txctl;
2286         int error = 0;
2287
2288         memset(&txctl, 0, sizeof(struct ath_tx_control));
2289         error = ath_tx_prepare(sc, skb, &txctl);
2290         if (error == 0)
2291                 /*
2292                  * Start DMA mapping.
2293                  * ath_tx_start_dma() will be called either synchronously
2294                  * or asynchrounsly once DMA is complete.
2295                  */
2296                 xmit_map_sg(sc, skb, &txctl);
2297         else
2298                 ath_node_put(sc, txctl.an, ATH9K_BH_STATUS_CHANGE);
2299
2300         /* failed packets will be dropped by the caller */
2301         return error;
2302 }
2303
2304 /* Deferred processing of transmit interrupt */
2305
2306 void ath_tx_tasklet(struct ath_softc *sc)
2307 {
2308         int i;
2309         u32 qcumask = ((1 << ATH9K_NUM_TX_QUEUES) - 1);
2310
2311         ath9k_hw_gettxintrtxqs(sc->sc_ah, &qcumask);
2312
2313         /*
2314          * Process each active queue.
2315          */
2316         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
2317                 if (ATH_TXQ_SETUP(sc, i) && (qcumask & (1 << i)))
2318                         ath_tx_processq(sc, &sc->sc_txq[i]);
2319         }
2320 }
2321
2322 void ath_tx_draintxq(struct ath_softc *sc,
2323         struct ath_txq *txq, bool retry_tx)
2324 {
2325         struct ath_buf *bf, *lastbf;
2326         struct list_head bf_head;
2327
2328         INIT_LIST_HEAD(&bf_head);
2329
2330         /*
2331          * NB: this assumes output has been stopped and
2332          *     we do not need to block ath_tx_tasklet
2333          */
2334         for (;;) {
2335                 spin_lock_bh(&txq->axq_lock);
2336
2337                 if (list_empty(&txq->axq_q)) {
2338                         txq->axq_link = NULL;
2339                         txq->axq_linkbuf = NULL;
2340                         spin_unlock_bh(&txq->axq_lock);
2341                         break;
2342                 }
2343
2344                 bf = list_first_entry(&txq->axq_q, struct ath_buf, list);
2345
2346                 if (bf->bf_status & ATH_BUFSTATUS_STALE) {
2347                         list_del(&bf->list);
2348                         spin_unlock_bh(&txq->axq_lock);
2349
2350                         spin_lock_bh(&sc->sc_txbuflock);
2351                         list_add_tail(&bf->list, &sc->sc_txbuf);
2352                         spin_unlock_bh(&sc->sc_txbuflock);
2353                         continue;
2354                 }
2355
2356                 lastbf = bf->bf_lastbf;
2357                 if (!retry_tx)
2358                         lastbf->bf_desc->ds_txstat.ts_flags =
2359                                 ATH9K_TX_SW_ABORTED;
2360
2361                 /* remove ath_buf's of the same mpdu from txq */
2362                 list_cut_position(&bf_head, &txq->axq_q, &lastbf->list);
2363                 txq->axq_depth--;
2364
2365                 spin_unlock_bh(&txq->axq_lock);
2366
2367                 if (bf_isampdu(bf))
2368                         ath_tx_complete_aggr_rifs(sc, txq, bf, &bf_head, 0);
2369                 else
2370                         ath_tx_complete_buf(sc, bf, &bf_head, 0, 0);
2371         }
2372
2373         /* flush any pending frames if aggregation is enabled */
2374         if (sc->sc_flags & SC_OP_TXAGGR) {
2375                 if (!retry_tx) {
2376                         spin_lock_bh(&txq->axq_lock);
2377                         ath_txq_drain_pending_buffers(sc, txq,
2378                                 ATH9K_BH_STATUS_CHANGE);
2379                         spin_unlock_bh(&txq->axq_lock);
2380                 }
2381         }
2382 }
2383
2384 /* Drain the transmit queues and reclaim resources */
2385
2386 void ath_draintxq(struct ath_softc *sc, bool retry_tx)
2387 {
2388         /* stop beacon queue. The beacon will be freed when
2389          * we go to INIT state */
2390         if (!(sc->sc_flags & SC_OP_INVALID)) {
2391                 (void) ath9k_hw_stoptxdma(sc->sc_ah, sc->sc_bhalq);
2392                 DPRINTF(sc, ATH_DBG_XMIT, "%s: beacon queue %x\n", __func__,
2393                         ath9k_hw_gettxbuf(sc->sc_ah, sc->sc_bhalq));
2394         }
2395
2396         ath_drain_txdataq(sc, retry_tx);
2397 }
2398
2399 u32 ath_txq_depth(struct ath_softc *sc, int qnum)
2400 {
2401         return sc->sc_txq[qnum].axq_depth;
2402 }
2403
2404 u32 ath_txq_aggr_depth(struct ath_softc *sc, int qnum)
2405 {
2406         return sc->sc_txq[qnum].axq_aggr_depth;
2407 }
2408
2409 /* Check if an ADDBA is required. A valid node must be passed. */
2410 enum ATH_AGGR_CHECK ath_tx_aggr_check(struct ath_softc *sc,
2411                                       struct ath_node *an,
2412                                       u8 tidno)
2413 {
2414         struct ath_atx_tid *txtid;
2415
2416         if (!(sc->sc_flags & SC_OP_TXAGGR))
2417                 return AGGR_NOT_REQUIRED;
2418
2419         /* ADDBA exchange must be completed before sending aggregates */
2420         txtid = ATH_AN_2_TID(an, tidno);
2421
2422         if (txtid->addba_exchangecomplete)
2423                 return AGGR_EXCHANGE_DONE;
2424
2425         if (txtid->cleanup_inprogress)
2426                 return AGGR_CLEANUP_PROGRESS;
2427
2428         if (txtid->addba_exchangeinprogress)
2429                 return AGGR_EXCHANGE_PROGRESS;
2430
2431         if (!txtid->addba_exchangecomplete) {
2432                 if (!txtid->addba_exchangeinprogress &&
2433                     (txtid->addba_exchangeattempts < ADDBA_EXCHANGE_ATTEMPTS)) {
2434                         txtid->addba_exchangeattempts++;
2435                         return AGGR_REQUIRED;
2436                 }
2437         }
2438
2439         return AGGR_NOT_REQUIRED;
2440 }
2441
2442 /* Start TX aggregation */
2443
2444 int ath_tx_aggr_start(struct ath_softc *sc,
2445                       const u8 *addr,
2446                       u16 tid,
2447                       u16 *ssn)
2448 {
2449         struct ath_atx_tid *txtid;
2450         struct ath_node *an;
2451
2452         spin_lock_bh(&sc->node_lock);
2453         an = ath_node_find(sc, (u8 *) addr);
2454         spin_unlock_bh(&sc->node_lock);
2455
2456         if (!an) {
2457                 DPRINTF(sc, ATH_DBG_AGGR,
2458                         "%s: Node not found to initialize "
2459                         "TX aggregation\n", __func__);
2460                 return -1;
2461         }
2462
2463         if (sc->sc_flags & SC_OP_TXAGGR) {
2464                 txtid = ATH_AN_2_TID(an, tid);
2465                 txtid->addba_exchangeinprogress = 1;
2466                 ath_tx_pause_tid(sc, txtid);
2467         }
2468
2469         return 0;
2470 }
2471
2472 /* Stop tx aggregation */
2473
2474 int ath_tx_aggr_stop(struct ath_softc *sc,
2475                      const u8 *addr,
2476                      u16 tid)
2477 {
2478         struct ath_node *an;
2479
2480         spin_lock_bh(&sc->node_lock);
2481         an = ath_node_find(sc, (u8 *) addr);
2482         spin_unlock_bh(&sc->node_lock);
2483
2484         if (!an) {
2485                 DPRINTF(sc, ATH_DBG_AGGR,
2486                         "%s: TX aggr stop for non-existent node\n", __func__);
2487                 return -1;
2488         }
2489
2490         ath_tx_aggr_teardown(sc, an, tid);
2491         return 0;
2492 }
2493
2494 /*
2495  * Performs transmit side cleanup when TID changes from aggregated to
2496  * unaggregated.
2497  * - Pause the TID and mark cleanup in progress
2498  * - Discard all retry frames from the s/w queue.
2499  */
2500
2501 void ath_tx_aggr_teardown(struct ath_softc *sc,
2502         struct ath_node *an, u8 tid)
2503 {
2504         struct ath_atx_tid *txtid = ATH_AN_2_TID(an, tid);
2505         struct ath_txq *txq = &sc->sc_txq[txtid->ac->qnum];
2506         struct ath_buf *bf;
2507         struct list_head bf_head;
2508         INIT_LIST_HEAD(&bf_head);
2509
2510         DPRINTF(sc, ATH_DBG_AGGR, "%s: teardown TX aggregation\n", __func__);
2511
2512         if (txtid->cleanup_inprogress) /* cleanup is in progress */
2513                 return;
2514
2515         if (!txtid->addba_exchangecomplete) {
2516                 txtid->addba_exchangeattempts = 0;
2517                 return;
2518         }
2519
2520         /* TID must be paused first */
2521         ath_tx_pause_tid(sc, txtid);
2522
2523         /* drop all software retried frames and mark this TID */
2524         spin_lock_bh(&txq->axq_lock);
2525         while (!list_empty(&txtid->buf_q)) {
2526                 bf = list_first_entry(&txtid->buf_q, struct ath_buf, list);
2527                 if (!bf_isretried(bf)) {
2528                         /*
2529                          * NB: it's based on the assumption that
2530                          * software retried frame will always stay
2531                          * at the head of software queue.
2532                          */
2533                         break;
2534                 }
2535                 list_cut_position(&bf_head,
2536                         &txtid->buf_q, &bf->bf_lastfrm->list);
2537                 ath_tx_update_baw(sc, txtid, bf->bf_seqno);
2538
2539                 /* complete this sub-frame */
2540                 ath_tx_complete_buf(sc, bf, &bf_head, 0, 0);
2541         }
2542
2543         if (txtid->baw_head != txtid->baw_tail) {
2544                 spin_unlock_bh(&txq->axq_lock);
2545                 txtid->cleanup_inprogress = true;
2546         } else {
2547                 txtid->addba_exchangecomplete = 0;
2548                 txtid->addba_exchangeattempts = 0;
2549                 spin_unlock_bh(&txq->axq_lock);
2550                 ath_tx_flush_tid(sc, txtid);
2551         }
2552 }
2553
2554 /*
2555  * Tx scheduling logic
2556  * NB: must be called with txq lock held
2557  */
2558
2559 void ath_txq_schedule(struct ath_softc *sc, struct ath_txq *txq)
2560 {
2561         struct ath_atx_ac *ac;
2562         struct ath_atx_tid *tid;
2563
2564         /* nothing to schedule */
2565         if (list_empty(&txq->axq_acq))
2566                 return;
2567         /*
2568          * get the first node/ac pair on the queue
2569          */
2570         ac = list_first_entry(&txq->axq_acq, struct ath_atx_ac, list);
2571         list_del(&ac->list);
2572         ac->sched = false;
2573
2574         /*
2575          * process a single tid per destination
2576          */
2577         do {
2578                 /* nothing to schedule */
2579                 if (list_empty(&ac->tid_q))
2580                         return;
2581
2582                 tid = list_first_entry(&ac->tid_q, struct ath_atx_tid, list);
2583                 list_del(&tid->list);
2584                 tid->sched = false;
2585
2586                 if (tid->paused)    /* check next tid to keep h/w busy */
2587                         continue;
2588
2589                 if (!(tid->an->an_smmode == ATH_SM_PWRSAV_DYNAMIC) ||
2590                     ((txq->axq_depth % 2) == 0)) {
2591                         ath_tx_sched_aggr(sc, txq, tid);
2592                 }
2593
2594                 /*
2595                  * add tid to round-robin queue if more frames
2596                  * are pending for the tid
2597                  */
2598                 if (!list_empty(&tid->buf_q))
2599                         ath_tx_queue_tid(txq, tid);
2600
2601                 /* only schedule one TID at a time */
2602                 break;
2603         } while (!list_empty(&ac->tid_q));
2604
2605         /*
2606          * schedule AC if more TIDs need processing
2607          */
2608         if (!list_empty(&ac->tid_q)) {
2609                 /*
2610                  * add dest ac to txq if not already added
2611                  */
2612                 if (!ac->sched) {
2613                         ac->sched = true;
2614                         list_add_tail(&ac->list, &txq->axq_acq);
2615                 }
2616         }
2617 }
2618
2619 /* Initialize per-node transmit state */
2620
2621 void ath_tx_node_init(struct ath_softc *sc, struct ath_node *an)
2622 {
2623         if (sc->sc_flags & SC_OP_TXAGGR) {
2624                 struct ath_atx_tid *tid;
2625                 struct ath_atx_ac *ac;
2626                 int tidno, acno;
2627
2628                 an->maxampdu = ATH_AMPDU_LIMIT_DEFAULT;
2629
2630                 /*
2631                  * Init per tid tx state
2632                  */
2633                 for (tidno = 0, tid = &an->an_aggr.tx.tid[tidno];
2634                                 tidno < WME_NUM_TID;
2635                                 tidno++, tid++) {
2636                         tid->an        = an;
2637                         tid->tidno     = tidno;
2638                         tid->seq_start = tid->seq_next = 0;
2639                         tid->baw_size  = WME_MAX_BA;
2640                         tid->baw_head  = tid->baw_tail = 0;
2641                         tid->sched     = false;
2642                         tid->paused = false;
2643                         tid->cleanup_inprogress = false;
2644                         INIT_LIST_HEAD(&tid->buf_q);
2645
2646                         acno = TID_TO_WME_AC(tidno);
2647                         tid->ac = &an->an_aggr.tx.ac[acno];
2648
2649                         /* ADDBA state */
2650                         tid->addba_exchangecomplete     = 0;
2651                         tid->addba_exchangeinprogress   = 0;
2652                         tid->addba_exchangeattempts     = 0;
2653                 }
2654
2655                 /*
2656                  * Init per ac tx state
2657                  */
2658                 for (acno = 0, ac = &an->an_aggr.tx.ac[acno];
2659                                 acno < WME_NUM_AC; acno++, ac++) {
2660                         ac->sched    = false;
2661                         INIT_LIST_HEAD(&ac->tid_q);
2662
2663                         switch (acno) {
2664                         case WME_AC_BE:
2665                                 ac->qnum = ath_tx_get_qnum(sc,
2666                                         ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_BE);
2667                                 break;
2668                         case WME_AC_BK:
2669                                 ac->qnum = ath_tx_get_qnum(sc,
2670                                         ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_BK);
2671                                 break;
2672                         case WME_AC_VI:
2673                                 ac->qnum = ath_tx_get_qnum(sc,
2674                                         ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_VI);
2675                                 break;
2676                         case WME_AC_VO:
2677                                 ac->qnum = ath_tx_get_qnum(sc,
2678                                         ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_VO);
2679                                 break;
2680                         }
2681                 }
2682         }
2683 }
2684
2685 /* Cleanupthe pending buffers for the node. */
2686
2687 void ath_tx_node_cleanup(struct ath_softc *sc,
2688         struct ath_node *an, bool bh_flag)
2689 {
2690         int i;
2691         struct ath_atx_ac *ac, *ac_tmp;
2692         struct ath_atx_tid *tid, *tid_tmp;
2693         struct ath_txq *txq;
2694         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
2695                 if (ATH_TXQ_SETUP(sc, i)) {
2696                         txq = &sc->sc_txq[i];
2697
2698                         if (likely(bh_flag))
2699                                 spin_lock_bh(&txq->axq_lock);
2700                         else
2701                                 spin_lock(&txq->axq_lock);
2702
2703                         list_for_each_entry_safe(ac,
2704                                         ac_tmp, &txq->axq_acq, list) {
2705                                 tid = list_first_entry(&ac->tid_q,
2706                                                 struct ath_atx_tid, list);
2707                                 if (tid && tid->an != an)
2708                                         continue;
2709                                 list_del(&ac->list);
2710                                 ac->sched = false;
2711
2712                                 list_for_each_entry_safe(tid,
2713                                                 tid_tmp, &ac->tid_q, list) {
2714                                         list_del(&tid->list);
2715                                         tid->sched = false;
2716                                         ath_tid_drain(sc, txq, tid, bh_flag);
2717                                         tid->addba_exchangecomplete = 0;
2718                                         tid->addba_exchangeattempts = 0;
2719                                         tid->cleanup_inprogress = false;
2720                                 }
2721                         }
2722
2723                         if (likely(bh_flag))
2724                                 spin_unlock_bh(&txq->axq_lock);
2725                         else
2726                                 spin_unlock(&txq->axq_lock);
2727                 }
2728         }
2729 }
2730
2731 /* Cleanup per node transmit state */
2732
2733 void ath_tx_node_free(struct ath_softc *sc, struct ath_node *an)
2734 {
2735         if (sc->sc_flags & SC_OP_TXAGGR) {
2736                 struct ath_atx_tid *tid;
2737                 int tidno, i;
2738
2739                 /* Init per tid rx state */
2740                 for (tidno = 0, tid = &an->an_aggr.tx.tid[tidno];
2741                         tidno < WME_NUM_TID;
2742                      tidno++, tid++) {
2743
2744                         for (i = 0; i < ATH_TID_MAX_BUFS; i++)
2745                                 ASSERT(tid->tx_buf[i] == NULL);
2746                 }
2747         }
2748 }
2749
2750 void ath_tx_cabq(struct ath_softc *sc, struct sk_buff *skb)
2751 {
2752         int hdrlen, padsize;
2753         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2754         struct ath_tx_control txctl;
2755
2756         /*
2757          * As a temporary workaround, assign seq# here; this will likely need
2758          * to be cleaned up to work better with Beacon transmission and virtual
2759          * BSSes.
2760          */
2761         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
2762                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
2763                 if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
2764                         sc->seq_no += 0x10;
2765                 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
2766                 hdr->seq_ctrl |= cpu_to_le16(sc->seq_no);
2767         }
2768
2769         /* Add the padding after the header if this is not already done */
2770         hdrlen = ieee80211_get_hdrlen_from_skb(skb);
2771         if (hdrlen & 3) {
2772                 padsize = hdrlen % 4;
2773                 if (skb_headroom(skb) < padsize) {
2774                         DPRINTF(sc, ATH_DBG_XMIT, "%s: TX CABQ padding "
2775                                 "failed\n", __func__);
2776                         dev_kfree_skb_any(skb);
2777                         return;
2778                 }
2779                 skb_push(skb, padsize);
2780                 memmove(skb->data, skb->data + padsize, hdrlen);
2781         }
2782
2783         DPRINTF(sc, ATH_DBG_XMIT, "%s: transmitting CABQ packet, skb: %p\n",
2784                 __func__,
2785                 skb);
2786
2787         memset(&txctl, 0, sizeof(struct ath_tx_control));
2788         txctl.flags = ATH9K_TXDESC_CAB;
2789         if (ath_tx_prepare(sc, skb, &txctl) == 0) {
2790                 /*
2791                  * Start DMA mapping.
2792                  * ath_tx_start_dma() will be called either synchronously
2793                  * or asynchrounsly once DMA is complete.
2794                  */
2795                 xmit_map_sg(sc, skb, &txctl);
2796         } else {
2797                 ath_node_put(sc, txctl.an, ATH9K_BH_STATUS_CHANGE);
2798                 DPRINTF(sc, ATH_DBG_XMIT, "%s: TX CABQ failed\n", __func__);
2799                 dev_kfree_skb_any(skb);
2800         }
2801 }
2802