target_firmware/wlan/if_owl.c

   1 /*
   2  * Copyright (c) 2013 Qualcomm Atheros, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted (subject to the limitations in the
   7  * disclaimer below) provided that the following conditions are met:
   8  *
   9  *  * Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  *  * Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  *  * Neither the name of Qualcomm Atheros nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
  22  * GRANTED BY THIS LICENSE.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
  23  * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
  24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  31  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  32  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  33  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include <adf_os_types.h>
  37 #include <adf_os_dma.h>
  38 #include <adf_os_timer.h>
  39 #include <adf_os_lock.h>
  40 #include <adf_os_io.h>
  41 #include <adf_os_mem.h>
  42 #include <adf_os_util.h>
  43 #include <adf_os_stdtypes.h>
  44 #include <adf_os_defer.h>
  45 #include <adf_os_atomic.h>
  46 #include <adf_nbuf.h>
  47 #include <adf_net.h>
  48 #include <adf_net_wcmd.h>
  49
  50 #include "if_llc.h"
  51
  52 #ifdef USE_HEADERLEN_RESV
  53 #include <if_llc.h>
  54 #endif
  55
  56 #include <ieee80211_var.h>
  57 #include "if_athrate.h"
  58 #include "if_athvar.h"
  59 #include "ah_desc.h"
  60
  61 #define ath_tgt_free_skb  adf_nbuf_free
  62
  63 #define OFDM_PLCP_BITS          22
  64 #define HT_RC_2_MCS(_rc)        ((_rc) & 0x0f)
  65 #define HT_RC_2_STREAMS(_rc)    ((((_rc) & 0x78) >> 3) + 1)
  66 #define L_STF                   8
  67 #define L_LTF                   8
  68 #define L_SIG                   4
  69 #define HT_SIG                  8
  70 #define HT_STF                  4
  71 #define HT_LTF(_ns)             (4 * (_ns))
  72 #define SYMBOL_TIME(_ns)        ((_ns) << 2)            // ns * 4 us
  73 #define SYMBOL_TIME_HALFGI(_ns) (((_ns) * 18 + 4) / 5)  // ns * 3.6 us
  74
  75 static a_uint16_t bits_per_symbol[][2] = {
  76         /* 20MHz 40MHz */
  77         {    26,   54 },     //  0: BPSK
  78         {    52,  108 },     //  1: QPSK 1/2
  79         {    78,  162 },     //  2: QPSK 3/4
  80         {   104,  216 },     //  3: 16-QAM 1/2
  81         {   156,  324 },     //  4: 16-QAM 3/4
  82         {   208,  432 },     //  5: 64-QAM 2/3
  83         {   234,  486 },     //  6: 64-QAM 3/4
  84         {   260,  540 },     //  7: 64-QAM 5/6
  85         {    52,  108 },     //  8: BPSK
  86         {   104,  216 },     //  9: QPSK 1/2
  87         {   156,  324 },     // 10: QPSK 3/4
  88         {   208,  432 },     // 11: 16-QAM 1/2
  89         {   312,  648 },     // 12: 16-QAM 3/4
  90         {   416,  864 },     // 13: 64-QAM 2/3
  91         {   468,  972 },     // 14: 64-QAM 3/4
  92         {   520, 1080 },     // 15: 64-QAM 5/6
  93 };
  94
  95 void owltgt_tx_processq(struct ath_softc_tgt *sc, struct ath_txq *txq,
  96                         owl_txq_state_t txqstate);
  97 static void ath_tgt_txqaddbuf(struct ath_softc_tgt *sc, struct ath_txq *txq,
  98                               struct ath_tx_buf *bf,  struct ath_tx_desc *lastds);
  99 void ath_rate_findrate_11n_Hardcoded(struct ath_softc_tgt *sc,
 100                                      struct ath_rc_series series[]);
 101 void ath_buf_set_rate_Hardcoded(struct ath_softc_tgt *sc,
 102                                 struct ath_tx_buf *bf) ;
 103 static a_int32_t ath_tgt_txbuf_setup(struct ath_softc_tgt *sc,
 104                                      struct ath_tx_buf *bf, ath_data_hdr_t *dh);
 105 static void ath_tx_freebuf(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 106 static void ath_tx_uc_comp(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 107 static void ath_update_stats(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 108 void adf_print_buf(adf_nbuf_t buf);
 109 static void ath_tgt_tx_enqueue(struct ath_txq *txq, struct ath_atx_tid  *tid);
 110
 111 void ath_tgt_tx_comp_aggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 112 struct ieee80211_frame *ATH_SKB_2_WH(adf_nbuf_t skb);
 113
 114 void ath_tgt_tx_send_normal(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 115
 116 static void ath_tgt_tx_sched_normal(struct ath_softc_tgt *sc, ath_atx_tid_t *tid);
 117 static void ath_tgt_tx_sched_aggr(struct ath_softc_tgt *sc, ath_atx_tid_t *tid);
 118
 119 extern a_int32_t ath_chainmask_sel_logic(void *);
 120 static a_int32_t ath_get_pktlen(struct ath_tx_buf *bf, a_int32_t hdrlen);
 121 static void ath_tgt_txq_schedule(struct ath_softc_tgt *sc, struct ath_txq *txq);
 122
 123 typedef void (*ath_ft_set_atype_t)(struct ath_softc_tgt *sc, struct ath_buf *bf);
 124
 125 static void
 126 ath_tx_set_retry(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 127
 128 static void
 129 ath_bar_tx(struct ath_softc_tgt *sc, ath_atx_tid_t *tid, struct ath_tx_buf *bf);
 130 static void
 131 ath_tx_update_baw(ath_atx_tid_t *tid, int seqno);
 132 static  void
 133 ath_tx_retry_subframe(struct ath_softc_tgt *sc, struct ath_tx_buf *bf,
 134                       ath_tx_bufhead *bf_q, struct ath_tx_buf **bar);
 135
 136 static void
 137 ath_tx_comp_aggr_error(struct ath_softc_tgt *sc, struct ath_tx_buf *bf, ath_atx_tid_t *tid);
 138
 139 void ath_tx_addto_baw(ath_atx_tid_t *tid, struct ath_tx_buf *bf);
 140 static inline void ath_tx_retry_unaggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 141 static void ath_tx_comp_unaggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 142 static void ath_update_aggr_stats(struct ath_softc_tgt *sc, struct ath_tx_desc *ds,
 143                                   int nframes, int nbad);
 144 static inline void ath_aggr_resume_tid(struct ath_softc_tgt *sc, ath_atx_tid_t *tid);
 145 static void ath_tx_comp_cleanup(struct ath_softc_tgt *sc, struct ath_tx_buf *bf);
 146
 147 int ath_tgt_tx_add_to_aggr(struct ath_softc_tgt *sc,
 148                            struct ath_buf *bf,int datatype,
 149                            ath_atx_tid_t *tid, int is_burst);
 150
 151 struct ieee80211_frame *ATH_SKB_2_WH(adf_nbuf_t skb)
 152 {
 153         a_uint8_t *anbdata;
 154         a_uint32_t anblen;
 155
 156         adf_nbuf_peek_header(skb, &anbdata, &anblen);
 157
 158         return((struct ieee80211_frame *)anbdata);
 159 }
 160
 161 #undef adf_os_cpu_to_le16
 162
 163 static a_uint16_t adf_os_cpu_to_le16(a_uint16_t x)
 164 {
 165         return ((((x) & 0xff00) >> 8) |   (((x) & 0x00ff) << 8));
 166 }
 167
 168 static inline void
 169 ath_aggr_resume_tid(struct ath_softc_tgt *sc, ath_atx_tid_t *tid)
 170 {
 171         struct ath_txq *txq;
 172
 173         txq = TID_TO_ACTXQ(tid->tidno);
 174         tid->paused = 0;
 175
 176         if (asf_tailq_empty(&tid->buf_q))
 177                 return;
 178
 179         ath_tgt_tx_enqueue(txq, tid);
 180         ath_tgt_txq_schedule(sc, txq);
 181 }
 182
 183 static inline void
 184 ath_aggr_pause_tid(struct ath_softc_tgt *sc, ath_atx_tid_t *tid)
 185 {
 186         tid->paused =1;
 187 }
 188
 189 static a_uint32_t ath_pkt_duration(struct ath_softc_tgt *sc,
 190                                    a_uint8_t rix, struct ath_tx_buf *bf,
 191                                    a_int32_t width, a_int32_t half_gi)
 192 {
 193         const HAL_RATE_TABLE *rt = sc->sc_currates;
 194         a_uint32_t nbits, nsymbits, duration, nsymbols;
 195         a_uint8_t rc;
 196         a_int32_t streams;
 197         a_int32_t pktlen;
 198
 199         pktlen = bf->bf_isaggr ? bf->bf_al : bf->bf_pktlen;
 200         rc = rt->info[rix].rateCode;
 201
 202         if (!IS_HT_RATE(rc))
 203                 return ath_hal_computetxtime(sc->sc_ah, rt, pktlen, rix,
 204                                              bf->bf_shpream);
 205
 206         nbits = (pktlen << 3) + OFDM_PLCP_BITS;
 207         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
 208         nsymbols = (nbits + nsymbits - 1) / nsymbits;
 209
 210         if (!half_gi)
 211                 duration = SYMBOL_TIME(nsymbols);
 212         else
 213                 duration = SYMBOL_TIME_HALFGI(nsymbols);
 214
 215         streams = HT_RC_2_STREAMS(rc);
 216         duration += L_STF + L_LTF + L_SIG + HT_SIG + HT_STF + HT_LTF(streams);
 217
 218         return duration;
 219 }
 220
 221 static void ath_dma_map(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 222 {
 223         adf_nbuf_t skb = bf->bf_skb;
 224
 225         skb = adf_nbuf_queue_first(&bf->bf_skbhead);
 226         adf_nbuf_map(sc->sc_dev, bf->bf_dmamap, skb, ADF_OS_DMA_TO_DEVICE);
 227 }
 228
 229 static void ath_dma_unmap(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 230 {
 231         adf_nbuf_t skb = bf->bf_skb;
 232
 233         skb = adf_nbuf_queue_first(&bf->bf_skbhead);
 234         adf_nbuf_unmap( sc->sc_dev, bf->bf_dmamap, ADF_OS_DMA_TO_DEVICE);
 235 }
 236
 237 static void ath_filltxdesc(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 238 {
 239         struct ath_tx_desc *ds0, *ds = bf->bf_desc;
 240         a_uint8_t i;
 241
 242         ds0 = ds;
 243         adf_nbuf_dmamap_info(bf->bf_dmamap, &bf->bf_dmamap_info);
 244
 245         for (i = 0; i < bf->bf_dmamap_info.nsegs; i++, ds++) {
 246
 247                 ds->ds_data = bf->bf_dmamap_info.dma_segs[i].paddr;
 248
 249                 if (i == (bf->bf_dmamap_info.nsegs - 1)) {
 250                         ds->ds_link = 0;
 251                         bf->bf_lastds = ds;
 252                 } else
 253                         ds->ds_link = ATH_BUF_GET_DESC_PHY_ADDR_WITH_IDX(bf, i+1);
 254
 255                 ath_hal_filltxdesc(sc->sc_ah, ds
 256                                    , bf->bf_dmamap_info.dma_segs[i].len
 257                                    , i == 0
 258                                    , i == (bf->bf_dmamap_info.nsegs - 1)
 259                                    , ds0);
 260         }
 261 }
 262
 263 static void ath_tx_tgt_setds(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 264 {
 265         struct ath_tx_desc *ds = bf->bf_desc;
 266         struct ath_hal *ah = sc->sc_ah;
 267
 268         switch (bf->bf_protmode) {
 269         case IEEE80211_PROT_RTSCTS:
 270                 bf->bf_flags |= HAL_TXDESC_RTSENA;
 271                 break;
 272         case IEEE80211_PROT_CTSONLY:
 273                 bf->bf_flags |= HAL_TXDESC_CTSENA;
 274                 break;
 275         default:
 276                 break;
 277         }
 278
 279         ah->ah_set11nTxDesc(ah, ds
 280                               , bf->bf_pktlen
 281                               , bf->bf_atype
 282                               , 60
 283                               , bf->bf_keyix
 284                               , bf->bf_keytype
 285                               , bf->bf_flags | HAL_TXDESC_INTREQ);
 286
 287         ath_filltxdesc(sc, bf);
 288 }
 289
 290 static struct ath_tx_buf *ath_buf_toggle(struct ath_softc_tgt *sc,
 291                                       struct ath_tx_buf *bf,
 292                                       a_uint8_t retry)
 293 {
 294         struct ath_tx_buf *tmp = NULL;
 295         adf_nbuf_t buf = NULL;
 296
 297         adf_os_assert(sc->sc_txbuf_held != NULL);
 298
 299         tmp = sc->sc_txbuf_held;
 300
 301         if (retry) {
 302                 ath_dma_unmap(sc, bf);
 303                 adf_nbuf_queue_init(&tmp->bf_skbhead);
 304                 buf = adf_nbuf_queue_remove(&bf->bf_skbhead);
 305                 adf_os_assert(buf);
 306                 adf_nbuf_queue_add(&tmp->bf_skbhead, buf);
 307
 308                 adf_os_assert(adf_nbuf_queue_len(&bf->bf_skbhead) == 0);
 309
 310                 tmp->bf_next = bf->bf_next;
 311                 tmp->bf_endpt = bf->bf_endpt;
 312                 tmp->bf_tidno = bf->bf_tidno;
 313                 tmp->bf_skb = bf->bf_skb;
 314                 tmp->bf_node = bf->bf_node;
 315                 tmp->bf_isaggr = bf->bf_isaggr;
 316                 tmp->bf_flags = bf->bf_flags;
 317                 tmp->bf_state = bf->bf_state;
 318                 tmp->bf_retries = bf->bf_retries;
 319                 tmp->bf_comp = bf->bf_comp;
 320                 tmp->bf_nframes = bf->bf_nframes;
 321                 tmp->bf_cookie = bf->bf_cookie;
 322
 323                 bf->bf_isaggr = 0;
 324                 bf->bf_next = NULL;
 325                 bf->bf_skb = NULL;
 326                 bf->bf_node = NULL;
 327                 bf->bf_flags = 0;
 328                 bf->bf_comp = NULL;
 329
 330                 bf->bf_retries = 0;
 331                 bf->bf_nframes = 0;
 332
 333                 ath_dma_map(sc, tmp);
 334                 ath_tx_tgt_setds(sc, tmp);
 335         }
 336
 337         sc->sc_txbuf_held = bf;
 338
 339         return tmp;
 340 }
 341
 342 static void ath_tgt_skb_free(struct ath_softc_tgt *sc,
 343                              adf_nbuf_queue_t *head,
 344                              HTC_ENDPOINT_ID endpt)
 345 {
 346         adf_nbuf_t tskb;
 347
 348         while (adf_nbuf_queue_len(head) != 0) {
 349                 tskb = adf_nbuf_queue_remove(head);
 350                 ath_free_tx_skb(sc->tgt_htc_handle,endpt,tskb);
 351         }
 352 }
 353
 354 static void ath_buf_comp(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 355 {
 356         ath_dma_unmap(sc, bf);
 357         ath_tgt_skb_free(sc, &bf->bf_skbhead,bf->bf_endpt);
 358         bf->bf_skb = NULL;
 359         bf->bf_node = NULL;
 360         bf = ath_buf_toggle(sc, bf, 0);
 361         if (bf != NULL) {
 362                 asf_tailq_insert_tail(&sc->sc_txbuf, bf, bf_list);
 363         }
 364 }
 365
 366 static void ath_buf_set_rate(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 367 {
 368     struct ath_hal *ah = sc->sc_ah;
 369     const HAL_RATE_TABLE *rt;
 370     struct ath_tx_desc *ds = bf->bf_desc;
 371     HAL_11N_RATE_SERIES series[4];
 372     a_int32_t i, flags;
 373     a_uint8_t rix, cix, rtsctsrate;
 374     a_uint32_t ctsduration = 0;
 375     a_int32_t prot_mode = AH_FALSE;
 376
 377     rt = sc->sc_currates;
 378     rix = bf->bf_rcs[0].rix;
 379     flags = (bf->bf_flags & (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA));
 380     cix = rt->info[sc->sc_protrix].controlRate;
 381
 382     if (bf->bf_protmode != IEEE80211_PROT_NONE &&
 383         (rt->info[rix].phy == IEEE80211_T_OFDM ||
 384          rt->info[rix].phy == IEEE80211_T_HT) &&
 385         (bf->bf_flags & HAL_TXDESC_NOACK) == 0) {
 386             cix = rt->info[sc->sc_protrix].controlRate;
 387             prot_mode = AH_TRUE;
 388     } else {
 389             if (ath_hal_htsupported(ah) && (!bf->bf_ismcast))
 390                     flags = HAL_TXDESC_RTSENA;
 391
 392             for (i = 4; i--;) {
 393                     if (bf->bf_rcs[i].tries) {
 394                             cix = rt->info[bf->bf_rcs[i].rix].controlRate;
 395                             break;
 396                     }
 397
 398             }
 399     }
 400
 401     adf_os_mem_set(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4);
 402
 403     for (i = 0; i < 4; i++) {
 404             if (!bf->bf_rcs[i].tries)
 405                     continue;
 406
 407             rix = bf->bf_rcs[i].rix;
 408
 409             series[i].Rate = rt->info[rix].rateCode |
 410                     (bf->bf_shpream ? rt->info[rix].shortPreamble : 0);
 411
 412             series[i].Tries = bf->bf_rcs[i].tries;
 413 #ifdef MAGPIE_MERLIN
 414             series[i].RateFlags = ((bf->bf_rcs[i].flags & ATH_RC_RTSCTS_FLAG) ?
 415                                    HAL_RATESERIES_RTS_CTS : 0 ) |
 416                     ((bf->bf_rcs[i].flags & ATH_RC_CW40_FLAG) ?
 417                      HAL_RATESERIES_2040 : 0 ) |
 418                     ((bf->bf_rcs[i].flags & ATH_RC_HT40_SGI_FLAG) ?
 419                      HAL_RATESERIES_HALFGI : 0 ) |
 420                     ((bf->bf_rcs[i].flags & ATH_RC_TX_STBC_FLAG) ?
 421                      HAL_RATESERIES_STBC: 0);
 422 #else
 423             series[i].RateFlags = ((bf->bf_rcs[i].flags & ATH_RC_RTSCTS_FLAG) ?
 424                                    HAL_RATESERIES_RTS_CTS : 0 ) |
 425                     ((bf->bf_rcs[i].flags & ATH_RC_CW40_FLAG) ?
 426                      HAL_RATESERIES_2040 : 0 ) |
 427                     ((bf->bf_rcs[i].flags & ATH_RC_HT40_SGI_FLAG) ?
 428                      HAL_RATESERIES_HALFGI : 0 );
 429 #endif
 430             series[i].PktDuration = ath_pkt_duration(sc, rix, bf,
 431                                      (bf->bf_rcs[i].flags & ATH_RC_CW40_FLAG) != 0,
 432                                      (bf->bf_rcs[i].flags & ATH_RC_HT40_SGI_FLAG));
 433
 434             series[i].ChSel = sc->sc_ic.ic_tx_chainmask;
 435
 436             if (prot_mode)
 437                     series[i].RateFlags |= HAL_RATESERIES_RTS_CTS;
 438
 439             if (bf->bf_rcs[i].flags & ATH_RC_DS_FLAG)
 440                     series[i].RateFlags |= HAL_RATESERIES_RTS_CTS;
 441     }
 442
 443     rtsctsrate = rt->info[cix].rateCode |
 444             (bf->bf_shpream ? rt->info[cix].shortPreamble : 0);
 445
 446     ah->ah_set11nRateScenario(ah, ds, 1,
 447                                 rtsctsrate, ctsduration,
 448                                 series, 4,
 449                                 flags);
 450 }
 451
 452 static void ath_tgt_rate_findrate(struct ath_softc_tgt *sc,
 453                                   struct ath_node_target *an,
 454                                   a_int32_t shortPreamble,
 455                                   size_t frameLen,
 456                                   a_int32_t numTries,
 457                                   a_int32_t numRates,
 458                                   a_int32_t stepDnInc,
 459                                   a_uint32_t rcflag,
 460                                   struct ath_rc_series series[],
 461                                   a_int32_t *isProbe)
 462 {
 463         ath_rate_findrate(sc, an, 1, frameLen, 10, 4, 1,
 464                           ATH_RC_PROBE_ALLOWED, series, isProbe);
 465 }
 466
 467 static void owl_tgt_tid_init(struct ath_atx_tid *tid)
 468 {
 469         int i;
 470
 471         tid->seq_start  = tid->seq_next = 0;
 472         tid->baw_size   = WME_MAX_BA;
 473         tid->baw_head   = tid->baw_tail = 0;
 474         tid->paused     = 0;
 475         tid->flag       = 0;
 476         tid->sched      = AH_FALSE;
 477
 478         asf_tailq_init(&tid->buf_q);
 479
 480         for (i = 0; i < ATH_TID_MAX_BUFS; i++) {
 481                 TX_BUF_BITMAP_CLR(tid->tx_buf_bitmap, i);
 482         }
 483 }
 484
 485 static void owl_tgt_tid_cleanup(struct ath_softc_tgt *sc,
 486                                 struct ath_atx_tid *tid)
 487 {
 488         tid->incomp--;
 489         if (tid->incomp) {
 490                 return;
 491         }
 492
 493         tid->flag &= ~TID_CLEANUP_INPROGRES;
 494
 495         if (tid->flag & TID_REINITIALIZE) {
 496                 adf_os_print("TID REINIT DONE for tid %p\n", tid);
 497                 tid->flag  &= ~TID_REINITIALIZE;
 498                 owl_tgt_tid_init(tid);
 499         } else {
 500                 ath_aggr_resume_tid(sc, tid);
 501         }
 502 }
 503
 504 void owl_tgt_node_init(struct ath_node_target * an)
 505 {
 506         struct ath_atx_tid *tid;
 507         int tidno;
 508
 509         for (tidno = 0, tid = &an->tid[tidno]; tidno < WME_NUM_TID;tidno++, tid++) {
 510                 tid->tidno = tidno;
 511                 tid->an = an;
 512
 513                 if ( tid->flag & TID_CLEANUP_INPROGRES ) {
 514                         tid->flag |= TID_REINITIALIZE;
 515                         adf_os_print("tid[%p]->incomp is not 0: %d\n",
 516                                      tid, tid->incomp);
 517                 } else {
 518                         owl_tgt_tid_init(tid);
 519                 }
 520         }
 521 }
 522
 523 void ath_tx_status_clear(struct ath_softc_tgt *sc)
 524 {
 525         int i;
 526
 527         for (i = 0; i < 2; i++) {
 528                 sc->tx_status[i].cnt = 0;
 529         }
 530 }
 531
 532 static WMI_TXSTATUS_EVENT *ath_tx_status_get(struct ath_softc_tgt *sc)
 533 {
 534         WMI_TXSTATUS_EVENT *txs = NULL;
 535         int i;
 536
 537         for (i = 0; i < 2; i++) {
 538                 if (sc->tx_status[i].cnt < HTC_MAX_TX_STATUS) {
 539                         txs = &sc->tx_status[i];
 540                         break;
 541                 }
 542         }
 543
 544         return txs;
 545 }
 546
 547 void ath_tx_status_update(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 548 {
 549         struct ath_tx_desc *ds = bf->bf_lastds;
 550         WMI_TXSTATUS_EVENT *txs;
 551
 552         if (sc->sc_tx_draining)
 553                 return;
 554
 555         txs = ath_tx_status_get(sc);
 556         if (txs == NULL)
 557                 return;
 558
 559         txs->txstatus[txs->cnt].cookie = bf->bf_cookie;
 560         txs->txstatus[txs->cnt].ts_rate = SM(bf->bf_endpt, ATH9K_HTC_TXSTAT_EPID);
 561
 562         if (ds->ds_txstat.ts_status & HAL_TXERR_FILT)
 563                 txs->txstatus[txs->cnt].ts_flags |= ATH9K_HTC_TXSTAT_FILT;
 564
 565         if (!(ds->ds_txstat.ts_status & HAL_TXERR_XRETRY) &&
 566             !(ds->ds_txstat.ts_status & HAL_TXERR_FIFO) &&
 567             !(ds->ds_txstat.ts_status & HAL_TXERR_TIMER_EXPIRED) &&
 568             !(ds->ds_txstat.ts_status & HAL_TXERR_FILT))
 569                 txs->txstatus[txs->cnt].ts_flags |= ATH9K_HTC_TXSTAT_ACK;
 570
 571         ath_tx_status_update_rate(sc, bf->bf_rcs, ds->ds_txstat.ts_rate, txs);
 572
 573         txs->cnt++;
 574 }
 575
 576 void ath_tx_status_update_aggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf,
 577                                struct ath_tx_desc *ds, struct ath_rc_series rcs[],
 578                                int txok)
 579 {
 580         WMI_TXSTATUS_EVENT *txs;
 581
 582         if (sc->sc_tx_draining)
 583                 return;
 584
 585         txs = ath_tx_status_get(sc);
 586         if (txs == NULL)
 587                 return;
 588
 589         txs->txstatus[txs->cnt].cookie = bf->bf_cookie;
 590         txs->txstatus[txs->cnt].ts_rate = SM(bf->bf_endpt, ATH9K_HTC_TXSTAT_EPID);
 591
 592         if (txok)
 593                 txs->txstatus[txs->cnt].ts_flags |= ATH9K_HTC_TXSTAT_ACK;
 594
 595         if (rcs)
 596                 ath_tx_status_update_rate(sc, rcs, ds->ds_txstat.ts_rate, txs);
 597
 598         txs->cnt++;
 599 }
 600
 601 void ath_tx_status_send(struct ath_softc_tgt *sc)
 602 {
 603         int i;
 604
 605         if (sc->sc_tx_draining)
 606                 return;
 607
 608         for (i = 0; i < 2; i++) {
 609                 if (sc->tx_status[i].cnt) {
 610                         wmi_event(sc->tgt_wmi_handle, WMI_TXSTATUS_EVENTID,
 611                                   &sc->tx_status[i], sizeof(WMI_TXSTATUS_EVENT));
 612                         /* FIXME: Handle failures. */
 613                         sc->tx_status[i].cnt = 0;
 614                 }
 615         }
 616 }
 617
 618 static void owltgt_tx_process_cabq(struct ath_softc_tgt *sc, struct ath_txq *txq)
 619 {
 620         struct ath_hal *ah = sc->sc_ah;
 621         ah->ah_setInterrupts(ah, sc->sc_imask & ~HAL_INT_SWBA);
 622         owltgt_tx_processq(sc, txq, OWL_TXQ_ACTIVE);
 623         ah->ah_setInterrupts(ah, sc->sc_imask);
 624 }
 625
 626 void owl_tgt_tx_tasklet(TQUEUE_ARG data)
 627 {
 628         struct ath_softc_tgt *sc = (struct ath_softc_tgt *)data;
 629         a_int32_t i;
 630         struct ath_txq *txq;
 631
 632         ath_tx_status_clear(sc);
 633
 634         for (i = 0; i < (HAL_NUM_TX_QUEUES - 6); i++) {
 635                 txq = ATH_TXQ(sc, i);
 636
 637                 if (ATH_TXQ_SETUP(sc, i)) {
 638                         if (txq == sc->sc_cabq)
 639                                 owltgt_tx_process_cabq(sc, txq);
 640                         else
 641                                 owltgt_tx_processq(sc, txq, OWL_TXQ_ACTIVE);
 642                 }
 643         }
 644
 645         ath_tx_status_send(sc);
 646 }
 647
 648 void owltgt_tx_processq(struct ath_softc_tgt *sc, struct ath_txq *txq,
 649                         owl_txq_state_t txqstate)
 650 {
 651         struct ath_tx_buf *bf;
 652         struct ath_tx_desc *ds;
 653         HAL_STATUS status;
 654
 655         for (;;) {
 656                 if (asf_tailq_empty(&txq->axq_q)) {
 657                         txq->axq_link = NULL;
 658                         txq->axq_linkbuf = NULL;
 659                         break;
 660                 }
 661
 662                 bf = asf_tailq_first(&txq->axq_q);
 663
 664                 ds = bf->bf_lastds;
 665                 status = ath_hal_txprocdesc(sc->sc_ah, ds);
 666
 667                 if (status == HAL_EINPROGRESS) {
 668                         if (txqstate == OWL_TXQ_ACTIVE)
 669                                 break;
 670                         else if (txqstate == OWL_TXQ_STOPPED) {
 671                                 __stats(sc, tx_stopfiltered);
 672                                 ds->ds_txstat.ts_flags  = 0;
 673                                 ds->ds_txstat.ts_status = HAL_OK;
 674                         } else {
 675                                 ds->ds_txstat.ts_flags  = HAL_TX_SW_FILTERED;
 676                         }
 677                 }
 678
 679                 ATH_TXQ_REMOVE_HEAD(txq, bf, bf_list);
 680                 if ((asf_tailq_empty(&txq->axq_q))) {
 681                         __stats(sc, tx_qnull);
 682                         txq->axq_link = NULL;
 683                         txq->axq_linkbuf = NULL;
 684                 }
 685
 686                 if (bf->bf_comp) {
 687                         bf->bf_comp(sc, bf);
 688                 } else {
 689                         ath_tx_status_update(sc, bf);
 690                         ath_buf_comp(sc, bf);
 691                 }
 692
 693                 if (txqstate == OWL_TXQ_ACTIVE) {
 694                         ath_tgt_txq_schedule(sc, txq);
 695                 }
 696         }
 697 }
 698
 699 static struct ieee80211_frame* ATH_SKB2_WH(adf_nbuf_t skb)
 700 {
 701         a_uint8_t *anbdata;
 702         a_uint32_t anblen;
 703
 704         adf_nbuf_peek_header(skb, &anbdata, &anblen);
 705         return((struct ieee80211_frame *)anbdata);
 706 }
 707
 708 void
 709 ath_tgt_tid_drain(struct ath_softc_tgt *sc, struct ath_atx_tid *tid)
 710 {
 711         struct ath_tx_buf *bf;
 712
 713         while (!asf_tailq_empty(&tid->buf_q)) {
 714                 TAILQ_DEQ(&tid->buf_q, bf, bf_list);
 715                 ath_tx_freebuf(sc, bf);
 716         }
 717
 718         tid->seq_next = tid->seq_start;
 719         tid->baw_tail = tid->baw_head;
 720 }
 721
 722 static void ath_tgt_tx_comp_normal(struct ath_softc_tgt *sc,
 723                                    struct ath_tx_buf *bf)
 724 {
 725         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
 726         ath_atx_tid_t *tid = ATH_AN_2_TID(an, bf->bf_tidno);
 727
 728         if (tid->flag & TID_CLEANUP_INPROGRES) {
 729                 owl_tgt_tid_cleanup(sc, tid);
 730         }
 731
 732         if (bf->bf_node) {
 733                 ath_tx_uc_comp(sc, bf);
 734         }
 735
 736         ath_tx_freebuf(sc, bf);
 737 }
 738
 739 static struct ieee80211_node_target * ath_tgt_find_node(struct ath_softc_tgt *sc,
 740                                                         a_int32_t node_index)
 741 {
 742         struct ath_node_target *an;
 743         struct ieee80211_node_target *ni;
 744
 745         if (node_index > TARGET_NODE_MAX)
 746                 return NULL;
 747
 748         an = &sc->sc_sta[node_index];
 749         ni = &an->ni;
 750
 751         if (an->an_valid) {
 752                 if (ni->ni_vap == NULL) {
 753                         return NULL;
 754                 }
 755                 return  ni;
 756         }
 757
 758         return NULL;
 759 }
 760
 761 static struct ath_tx_buf* ath_tx_buf_alloc(struct ath_softc_tgt *sc)
 762 {
 763         struct ath_tx_buf *bf = NULL;
 764
 765         bf = asf_tailq_first(&sc->sc_txbuf);
 766         if (bf !=  NULL) {
 767                 adf_os_mem_set(&bf->bf_state, 0, sizeof(struct ath_buf_state));
 768                 asf_tailq_remove(&sc->sc_txbuf, bf, bf_list);
 769         } else {
 770                 adf_os_assert(0);
 771         }
 772
 773         return  bf;
 774 }
 775
 776 struct ath_tx_buf* ath_tgt_tx_prepare(struct ath_softc_tgt *sc,
 777                                    adf_nbuf_t skb, ath_data_hdr_t *dh)
 778 {
 779         struct ath_tx_buf *bf;
 780         struct ieee80211_node_target *ni;
 781         struct ath_atx_tid *tid;
 782
 783         ni = ath_tgt_find_node(sc, dh->ni_index);
 784         if (ni == NULL)
 785                 return NULL;
 786
 787         tid = ATH_AN_2_TID(ATH_NODE_TARGET(ni), dh->tidno);
 788         if (tid->flag & TID_REINITIALIZE) {
 789                 adf_os_print("drop frame due to TID reinit\n");
 790                 return NULL;
 791         }
 792
 793         bf = ath_tx_buf_alloc(sc);
 794         if (!bf) {
 795                 __stats(sc, tx_nobufs);
 796                 return NULL;
 797         }
 798
 799         bf->bf_tidno = dh->tidno;
 800         bf->bf_txq = TID_TO_ACTXQ(bf->bf_tidno);
 801         bf->bf_keytype = dh->keytype;
 802         bf->bf_keyix = dh->keyix;
 803         bf->bf_protmode = dh->flags & (IEEE80211_PROT_RTSCTS | IEEE80211_PROT_CTSONLY);
 804         bf->bf_node = ni;
 805
 806         adf_nbuf_queue_add(&bf->bf_skbhead, skb);
 807         skb = adf_nbuf_queue_first(&(bf->bf_skbhead));
 808
 809         if (adf_nbuf_queue_len(&(bf->bf_skbhead)) == 0) {
 810                 __stats(sc, tx_noskbs);
 811                 return NULL;
 812         }
 813
 814         adf_os_assert(skb);
 815
 816         bf->bf_skb = skb;
 817
 818         ath_tgt_txbuf_setup(sc, bf, dh);
 819         ath_dma_map(sc, bf);
 820         ath_tx_tgt_setds(sc, bf);
 821
 822         return bf;
 823 }
 824
 825 static void ath_tgt_tx_seqno_normal(struct ath_tx_buf *bf)
 826 {
 827         struct ieee80211_node_target *ni = bf->bf_node;
 828         struct ath_node_target *an = ATH_NODE_TARGET(ni);
 829         struct ieee80211_frame *wh = ATH_SKB_2_WH(bf->bf_skb);
 830         struct ath_atx_tid *tid = ATH_AN_2_TID(an, bf->bf_tidno);
 831
 832         u_int8_t fragno = (wh->i_seq[0] & 0xf);
 833
 834         INCR(ni->ni_txseqmgmt, IEEE80211_SEQ_MAX);
 835
 836         bf->bf_seqno = (tid->seq_next << IEEE80211_SEQ_SEQ_SHIFT);
 837
 838         *(u_int16_t *)wh->i_seq = adf_os_cpu_to_le16(bf->bf_seqno);
 839         wh->i_seq[0] |= fragno;
 840
 841         if (!(wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG))
 842                 INCR(tid->seq_next, IEEE80211_SEQ_MAX);
 843 }
 844
 845 static a_int32_t ath_key_setup(struct ieee80211_node_target *ni,
 846                                struct ath_tx_buf *bf)
 847 {
 848         struct ieee80211_frame *wh = ATH_SKB_2_WH(bf->bf_skb);
 849
 850         if (!(wh->i_fc[1] & IEEE80211_FC1_WEP)) {
 851                 bf->bf_keytype = HAL_KEY_TYPE_CLEAR;
 852                 bf->bf_keyix = HAL_TXKEYIX_INVALID;
 853                 return 0;
 854         }
 855
 856         switch (bf->bf_keytype) {
 857         case HAL_KEY_TYPE_WEP:
 858                 bf->bf_pktlen += IEEE80211_WEP_ICVLEN;
 859                 break;
 860         case HAL_KEY_TYPE_AES:
 861                 bf->bf_pktlen += IEEE80211_WEP_MICLEN;
 862                 break;
 863         case HAL_KEY_TYPE_TKIP:
 864                 bf->bf_pktlen += IEEE80211_WEP_ICVLEN;
 865                 break;
 866         default:
 867                 break;
 868         }
 869
 870         if (bf->bf_keytype == HAL_KEY_TYPE_AES ||
 871             bf->bf_keytype == HAL_KEY_TYPE_TKIP)
 872                 ieee80211_tgt_crypto_encap(wh, ni, bf->bf_keytype);
 873
 874         return 0;
 875 }
 876
 877 static void ath_tgt_txq_add_ucast(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 878 {
 879         struct ath_hal *ah = sc->sc_ah;
 880         struct ath_txq *txq;
 881         HAL_STATUS status;
 882         volatile a_int32_t txe_val;
 883
 884         adf_os_assert(bf);
 885
 886         txq = bf->bf_txq;
 887
 888         status = ath_hal_txprocdesc(sc->sc_ah, bf->bf_lastds);
 889
 890         ATH_TXQ_INSERT_TAIL(txq, bf, bf_list);
 891
 892         if (txq->axq_link == NULL) {
 893                 ah->ah_setTxDP(ah, txq->axq_qnum, ATH_BUF_GET_DESC_PHY_ADDR(bf));
 894         } else {
 895                 *txq->axq_link = ATH_BUF_GET_DESC_PHY_ADDR(bf);
 896
 897                 txe_val = OS_REG_READ(ah, 0x840);
 898                 if (!(txe_val & (1<< txq->axq_qnum)))
 899                         ah->ah_setTxDP(ah, txq->axq_qnum, ATH_BUF_GET_DESC_PHY_ADDR(bf));
 900         }
 901
 902         txq->axq_link = &bf->bf_lastds->ds_link;
 903         ah->ah_startTxDma(ah, txq->axq_qnum);
 904 }
 905
 906 static a_int32_t ath_tgt_txbuf_setup(struct ath_softc_tgt *sc,
 907                                      struct ath_tx_buf *bf,
 908                                      ath_data_hdr_t *dh)
 909
 910 {
 911         struct ieee80211_frame *wh = ATH_SKB2_WH(bf->bf_skb);
 912         a_int32_t retval;
 913         a_uint32_t flags = adf_os_ntohl(dh->flags);
 914
 915         ath_tgt_tx_seqno_normal(bf);
 916
 917         bf->bf_txq_add  = ath_tgt_txq_add_ucast;
 918         bf->bf_hdrlen   = ieee80211_anyhdrsize(wh);
 919         bf->bf_pktlen   = ath_get_pktlen(bf, bf->bf_hdrlen);
 920         bf->bf_ismcast  = IEEE80211_IS_MULTICAST(wh->i_addr1);
 921
 922         if ((retval = ath_key_setup(bf->bf_node, bf)) < 0)
 923                 return retval;
 924
 925         if (flags & ATH_SHORT_PREAMBLE)
 926                 bf->bf_shpream = AH_TRUE;
 927         else
 928                 bf->bf_shpream = AH_FALSE;
 929
 930         bf->bf_flags = HAL_TXDESC_CLRDMASK;
 931         bf->bf_atype = HAL_PKT_TYPE_NORMAL;
 932
 933         return 0;
 934 }
 935
 936 static a_int32_t
 937 ath_get_pktlen(struct ath_tx_buf *bf, a_int32_t hdrlen)
 938 {
 939         adf_nbuf_t skb = bf->bf_skb;
 940         a_int32_t pktlen;
 941
 942         skb = adf_nbuf_queue_first(&bf->bf_skbhead);
 943         pktlen = adf_nbuf_len(skb);
 944
 945         pktlen -= (hdrlen & 3);
 946         pktlen += IEEE80211_CRC_LEN;
 947
 948         return pktlen;
 949 }
 950
 951 void
 952 ath_tgt_tx_send_normal(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 953 {
 954         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
 955         struct ath_rc_series rcs[4];
 956         struct ath_rc_series mrcs[4];
 957         a_int32_t shortPreamble = 0;
 958         a_int32_t isProbe = 0;
 959
 960         adf_os_mem_set(rcs, 0, sizeof(struct ath_rc_series)*4 );
 961         adf_os_mem_set(mrcs, 0, sizeof(struct ath_rc_series)*4 );
 962
 963         if (!bf->bf_ismcast) {
 964                 ath_tgt_rate_findrate(sc, an, shortPreamble,
 965                                       0, 0, 0, 0, 0,
 966                                       rcs, &isProbe);
 967                 ath_hal_memcpy(bf->bf_rcs, rcs, sizeof(rcs));
 968         } else {
 969                 mrcs[1].tries = mrcs[2].tries = mrcs[3].tries = 0;
 970                 mrcs[1].rix = mrcs[2].rix = mrcs[3].rix = 0;
 971                 mrcs[0].rix   = 0;
 972                 mrcs[0].tries = 1;
 973                 mrcs[0].flags = 0;
 974                 ath_hal_memcpy(bf->bf_rcs, mrcs, sizeof(mrcs));
 975         }
 976
 977         ath_buf_set_rate(sc, bf);
 978         bf->bf_txq_add(sc, bf);
 979 }
 980
 981 static void
 982 ath_tx_freebuf(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
 983 {
 984         a_int32_t i ;
 985         struct ath_tx_desc *bfd = NULL;
 986         struct ath_hal *ah = sc->sc_ah;
 987
 988         for (bfd = bf->bf_desc, i = 0; i < bf->bf_dmamap_info.nsegs; bfd++, i++) {
 989                 ah->ah_clr11nAggr(sc->sc_ah, bfd);
 990                 ath_hal_set11n_burstduration(sc->sc_ah, bfd, 0);
 991                 ath_hal_set11n_virtualmorefrag(sc->sc_ah, bfd, 0);
 992         }
 993
 994         ath_dma_unmap(sc, bf);
 995
 996         ath_tgt_skb_free(sc, &bf->bf_skbhead,bf->bf_endpt);
 997
 998         bf->bf_skb = NULL;
 999         bf->bf_comp = NULL;
1000         bf->bf_node = NULL;
1001         bf->bf_next = NULL;
1002         bf = ath_buf_toggle(sc, bf, 0);
1003         bf->bf_retries = 0;
1004         bf->bf_isretried = 0;
1005
1006         if (bf != NULL)
1007                 asf_tailq_insert_tail(&sc->sc_txbuf, bf, bf_list);
1008 }
1009
1010 static void
1011 ath_tx_uc_comp(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1012 {
1013         ath_tx_status_update(sc, bf);
1014         ath_update_stats(sc, bf);
1015         ath_rate_tx_complete(sc, ATH_NODE_TARGET(bf->bf_node),
1016                              bf->bf_lastds, bf->bf_rcs, 1, 0);
1017 }
1018
1019 static void
1020 ath_update_stats(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1021 {
1022         struct ath_tx_desc *ds = bf->bf_desc;
1023         u_int32_t sr, lr;
1024
1025         if (ds->ds_txstat.ts_status == 0) {
1026                 if (ds->ds_txstat.ts_rate & HAL_TXSTAT_ALTRATE)
1027                         sc->sc_tx_stats.ast_tx_altrate++;
1028         } else {
1029                 if (ds->ds_txstat.ts_status & HAL_TXERR_XRETRY)
1030                         sc->sc_tx_stats.ast_tx_xretries++;
1031                 if (ds->ds_txstat.ts_status & HAL_TXERR_FIFO)
1032                         sc->sc_tx_stats.ast_tx_fifoerr++;
1033                 if (ds->ds_txstat.ts_status & HAL_TXERR_FILT)
1034                         sc->sc_tx_stats.ast_tx_filtered++;
1035                 if (ds->ds_txstat.ts_status & HAL_TXERR_TIMER_EXPIRED)
1036                         sc->sc_tx_stats.ast_tx_timer_exp++;
1037         }
1038         sr = ds->ds_txstat.ts_shortretry;
1039         lr = ds->ds_txstat.ts_longretry;
1040         sc->sc_tx_stats.ast_tx_shortretry += sr;
1041         sc->sc_tx_stats.ast_tx_longretry += lr;
1042 }
1043
1044 void
1045 ath_tgt_send_mgt(struct ath_softc_tgt *sc,adf_nbuf_t hdr_buf, adf_nbuf_t skb,
1046                  HTC_ENDPOINT_ID endpt)
1047 {
1048         struct ieee80211_node_target *ni;
1049         struct ieee80211vap_target *vap;
1050         struct ath_vap_target *avp;
1051         struct ath_hal *ah = sc->sc_ah;
1052         a_uint8_t rix, txrate, ctsrate, cix = 0xff, *data;
1053         a_uint32_t ivlen = 0, icvlen = 0, subtype, flags, ctsduration;
1054         a_int32_t i, iswep, ismcast, hdrlen, pktlen, try0, len;
1055         struct ath_tx_desc *ds=NULL;
1056         struct ath_txq *txq=NULL;
1057         struct ath_tx_buf *bf;
1058         HAL_PKT_TYPE atype;
1059         const HAL_RATE_TABLE *rt;
1060         HAL_BOOL shortPreamble;
1061         struct ieee80211_frame *wh;
1062         struct ath_rc_series rcs[4];
1063         HAL_11N_RATE_SERIES series[4];
1064         ath_mgt_hdr_t *mh;
1065         a_int8_t keyix;
1066
1067         if (!hdr_buf) {
1068                 adf_nbuf_peek_header(skb, &data, &len);
1069                 adf_nbuf_pull_head(skb, sizeof(ath_mgt_hdr_t));
1070         } else {
1071                 adf_nbuf_peek_header(hdr_buf, &data, &len);
1072         }
1073
1074         adf_os_assert(len >= sizeof(ath_mgt_hdr_t));
1075
1076         mh = (ath_mgt_hdr_t *)data;
1077         adf_nbuf_peek_header(skb, &data, &len);
1078         wh = (struct ieee80211_frame *)data;
1079
1080         adf_os_mem_set(rcs, 0, sizeof(struct ath_rc_series)*4);
1081         adf_os_mem_set(series, 0, sizeof(HAL_11N_RATE_SERIES)*4);
1082
1083         bf = asf_tailq_first(&sc->sc_txbuf);
1084         if (!bf)
1085                 goto fail;
1086
1087         asf_tailq_remove(&sc->sc_txbuf, bf, bf_list);
1088
1089         ni = ath_tgt_find_node(sc, mh->ni_index);
1090         if (!ni)
1091                 goto fail;
1092
1093         bf->bf_endpt = endpt;
1094         bf->bf_cookie = mh->cookie;
1095         bf->bf_protmode = mh->flags & (IEEE80211_PROT_RTSCTS | IEEE80211_PROT_CTSONLY);
1096         txq = &sc->sc_txq[1];
1097         iswep = wh->i_fc[1] & IEEE80211_FC1_WEP;
1098         ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1);
1099         hdrlen = ieee80211_anyhdrsize(wh);
1100         pktlen = len;
1101         keyix = HAL_TXKEYIX_INVALID;
1102         pktlen -= (hdrlen & 3);
1103         pktlen += IEEE80211_CRC_LEN;
1104
1105         if (iswep)
1106                 keyix = mh->keyix;
1107
1108         adf_nbuf_map(sc->sc_dev, bf->bf_dmamap, skb, ADF_OS_DMA_TO_DEVICE);
1109
1110         bf->bf_skb = skb;
1111         adf_nbuf_queue_add(&bf->bf_skbhead, skb);
1112
1113         ds = bf->bf_desc;
1114         rt = sc->sc_currates;
1115         adf_os_assert(rt != NULL);
1116
1117         if (mh->flags == ATH_SHORT_PREAMBLE)
1118                 shortPreamble = AH_TRUE;
1119         else
1120                 shortPreamble = AH_FALSE;
1121
1122         flags = HAL_TXDESC_CLRDMASK;
1123
1124         switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
1125         case IEEE80211_FC0_TYPE_MGT:
1126                 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
1127
1128                 if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)
1129                         atype = HAL_PKT_TYPE_PROBE_RESP;
1130                 else if (subtype == IEEE80211_FC0_SUBTYPE_ATIM)
1131                         atype = HAL_PKT_TYPE_ATIM;
1132                 else
1133                         atype = HAL_PKT_TYPE_NORMAL;
1134
1135                 break;
1136         default:
1137                 atype = HAL_PKT_TYPE_NORMAL;
1138                 break;
1139         }
1140
1141         avp = &sc->sc_vap[mh->vap_index];
1142
1143         rcs[0].rix = ath_get_minrateidx(sc, avp);
1144         rcs[0].tries = ATH_TXMAXTRY;
1145         rcs[0].flags = 0;
1146
1147         adf_os_mem_copy(bf->bf_rcs, rcs, sizeof(rcs));
1148         rix = rcs[0].rix;
1149         try0 = rcs[0].tries;
1150         txrate = rt->info[rix].rateCode;
1151
1152         if (shortPreamble){
1153                 txrate |= rt->info[rix].shortPreamble;
1154         }
1155
1156         vap = ni->ni_vap;
1157         bf->bf_node = ni;
1158
1159         if (ismcast) {
1160                 flags |= HAL_TXDESC_NOACK;
1161                 try0 = 1;
1162         } else if (pktlen > vap->iv_rtsthreshold) {
1163                 flags |= HAL_TXDESC_RTSENA;
1164                 cix = rt->info[rix].controlRate;
1165         }
1166
1167         if ((bf->bf_protmode != IEEE80211_PROT_NONE) &&
1168             rt->info[rix].phy == IEEE80211_T_OFDM &&
1169             (flags & HAL_TXDESC_NOACK) == 0) {
1170                 cix = rt->info[sc->sc_protrix].controlRate;
1171                 sc->sc_tx_stats.ast_tx_protect++;
1172         }
1173
1174         *(a_uint16_t *)&wh->i_seq[0] =  adf_os_cpu_to_le16(ni->ni_txseqmgmt <<
1175                                                            IEEE80211_SEQ_SEQ_SHIFT);
1176         INCR(ni->ni_txseqmgmt, IEEE80211_SEQ_MAX);
1177
1178         ctsduration = 0;
1179         if (flags & (HAL_TXDESC_RTSENA|HAL_TXDESC_CTSENA)) {
1180                 adf_os_assert(cix != 0xff);
1181                 ctsrate = rt->info[cix].rateCode;
1182                 if (shortPreamble) {
1183                         ctsrate |= rt->info[cix].shortPreamble;
1184                         if (flags & HAL_TXDESC_RTSENA)      /* SIFS + CTS */
1185                                 ctsduration += rt->info[cix].spAckDuration;
1186                         if ((flags & HAL_TXDESC_NOACK) == 0)    /* SIFS + ACK */
1187                                 ctsduration += rt->info[cix].spAckDuration;
1188                 } else {
1189                         if (flags & HAL_TXDESC_RTSENA)      /* SIFS + CTS */
1190                                 ctsduration += rt->info[cix].lpAckDuration;
1191                         if ((flags & HAL_TXDESC_NOACK) == 0)    /* SIFS + ACK */
1192                                 ctsduration += rt->info[cix].lpAckDuration;
1193                 }
1194                 ctsduration += ath_hal_computetxtime(ah,
1195                                                      rt, pktlen, rix, shortPreamble);
1196                 try0 = 1;
1197         } else
1198                 ctsrate = 0;
1199
1200         flags |= HAL_TXDESC_INTREQ;
1201
1202         ath_hal_setuptxdesc(ah, ds
1203                             , pktlen
1204                             , hdrlen
1205                             , atype
1206                             , 60
1207                             , txrate, try0
1208                             , keyix
1209                             , 0
1210                             , flags
1211                             , ctsrate
1212                             , ctsduration
1213                             , icvlen
1214                             , ivlen
1215                             , ATH_COMP_PROC_NO_COMP_NO_CCS);
1216
1217         bf->bf_flags = flags;
1218
1219         /*
1220          * Set key type in tx desc while sending the encrypted challenge to AP
1221          * in Auth frame 3 of Shared Authentication, owl needs this.
1222          */
1223         if (iswep && (keyix != HAL_TXKEYIX_INVALID) &&
1224             (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) == IEEE80211_FC0_SUBTYPE_AUTH)
1225                 ath_hal_fillkeytxdesc(ah, ds, mh->keytype);
1226
1227         ath_filltxdesc(sc, bf);
1228
1229         for (i=0; i<4; i++) {
1230                 series[i].Tries = 2;
1231                 series[i].Rate = txrate;
1232                 series[i].ChSel = sc->sc_ic.ic_tx_chainmask;
1233                 series[i].RateFlags = 0;
1234         }
1235         ah->ah_set11nRateScenario(ah, ds, 0, ctsrate, ctsduration, series, 4, 0);
1236         ath_tgt_txqaddbuf(sc, txq, bf, bf->bf_lastds);
1237
1238         return;
1239 fail:
1240         HTC_ReturnBuffers(sc->tgt_htc_handle, endpt, skb);
1241         return;
1242 }
1243
1244 static void
1245 ath_tgt_txqaddbuf(struct ath_softc_tgt *sc,
1246                   struct ath_txq *txq, struct ath_tx_buf *bf,
1247                   struct ath_tx_desc *lastds)
1248 {
1249         struct ath_hal *ah = sc->sc_ah;
1250
1251         ATH_TXQ_INSERT_TAIL(txq, bf, bf_list);
1252
1253         if (txq->axq_link == NULL) {
1254                 ah->ah_setTxDP(ah, txq->axq_qnum, ATH_BUF_GET_DESC_PHY_ADDR(bf));
1255         } else {
1256                 *txq->axq_link = ATH_BUF_GET_DESC_PHY_ADDR(bf);
1257         }
1258
1259         txq->axq_link = &lastds->ds_link;
1260         ah->ah_startTxDma(ah, txq->axq_qnum);
1261 }
1262
1263 void ath_tgt_handle_normal(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1264 {
1265         ath_atx_tid_t *tid;
1266         struct ath_node_target *an;
1267
1268         an = (struct ath_node_target *)bf->bf_node;
1269         adf_os_assert(an);
1270
1271         tid = &an->tid[bf->bf_tidno];
1272         adf_os_assert(tid);
1273
1274         bf->bf_comp = ath_tgt_tx_comp_normal;
1275         INCR(tid->seq_start, IEEE80211_SEQ_MAX);
1276         ath_tgt_tx_send_normal(sc, bf);
1277 }
1278
1279 static void
1280 ath_tgt_tx_enqueue(struct ath_txq *txq, struct ath_atx_tid  *tid)
1281 {
1282         if (tid->paused)
1283                 return;
1284
1285         if (tid->sched)
1286                 return;
1287
1288         tid->sched = AH_TRUE;
1289         asf_tailq_insert_tail(&txq->axq_tidq, tid, tid_qelem);
1290 }
1291
1292 static void
1293 ath_tgt_txq_schedule(struct ath_softc_tgt *sc, struct ath_txq *txq)
1294 {
1295         struct ath_atx_tid  *tid;
1296         u_int8_t bdone;
1297
1298         bdone = AH_FALSE;
1299
1300         do {
1301                 TAILQ_DEQ(&txq->axq_tidq, tid, tid_qelem);
1302
1303                 if (tid == NULL)
1304                         return;
1305
1306                 tid->sched = AH_FALSE;
1307
1308                 if (tid->paused)
1309                         continue;
1310
1311                 if (!(tid->flag & TID_AGGR_ENABLED))
1312                         ath_tgt_tx_sched_normal(sc,tid);
1313                 else
1314                         ath_tgt_tx_sched_aggr(sc,tid);
1315
1316                 bdone = AH_TRUE;
1317
1318                 if (!asf_tailq_empty(&tid->buf_q)) {
1319                         ath_tgt_tx_enqueue(txq, tid);
1320                 }
1321
1322         } while (!asf_tailq_empty(&txq->axq_tidq) && !bdone);
1323 }
1324
1325 void
1326 ath_tgt_handle_aggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1327 {
1328         ath_atx_tid_t *tid;
1329         struct ath_node_target *an;
1330         struct ath_txq *txq = bf->bf_txq;
1331         a_bool_t queue_frame, within_baw;
1332
1333         an = (struct ath_node_target *)bf->bf_node;
1334         adf_os_assert(an);
1335
1336         tid = &an->tid[bf->bf_tidno];
1337         adf_os_assert(tid);
1338
1339         bf->bf_comp = ath_tgt_tx_comp_aggr;
1340
1341         within_baw = BAW_WITHIN(tid->seq_start, tid->baw_size,
1342                                 SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1343
1344         queue_frame = ( (txq->axq_depth >= ATH_AGGR_MIN_QDEPTH) ||
1345                         (!asf_tailq_empty(&tid->buf_q)) ||
1346                         (tid->paused) || (!within_baw) );
1347
1348         if (queue_frame) {
1349                 asf_tailq_insert_tail(&tid->buf_q, bf, bf_list);
1350                 ath_tgt_tx_enqueue(txq, tid);
1351         } else {
1352                 ath_tx_addto_baw(tid, bf);
1353                 __stats(sc, txaggr_nframes);
1354                 ath_tgt_tx_send_normal(sc, bf);
1355         }
1356 }
1357
1358 static void
1359 ath_tgt_tx_sched_normal(struct ath_softc_tgt *sc, ath_atx_tid_t *tid)
1360 {
1361         struct ath_tx_buf *bf;
1362         struct ath_txq *txq =TID_TO_ACTXQ(tid->tidno);;
1363
1364         do {
1365                 if (asf_tailq_empty(&tid->buf_q))
1366                         break;
1367
1368                 bf = asf_tailq_first(&tid->buf_q);
1369                 asf_tailq_remove(&tid->buf_q, bf, bf_list);
1370                 ath_tgt_tx_send_normal(sc, bf);
1371
1372         } while (txq->axq_depth < ATH_AGGR_MIN_QDEPTH);
1373 }
1374
1375 static void
1376 ath_tgt_tx_sched_aggr(struct ath_softc_tgt *sc, ath_atx_tid_t *tid)
1377 {
1378         struct ath_tx_buf  *bf, *bf_last;
1379         ATH_AGGR_STATUS status;
1380         ath_tx_bufhead bf_q;
1381         struct ath_txq *txq = TID_TO_ACTXQ(tid->tidno);
1382         struct ath_tx_desc *ds = NULL;
1383         struct ath_hal *ah = sc->sc_ah;
1384         int i;
1385
1386
1387         if (asf_tailq_empty(&tid->buf_q))
1388                 return;
1389
1390         do {
1391                 if (asf_tailq_empty(&tid->buf_q))
1392                         break;
1393
1394                 asf_tailq_init(&bf_q);
1395
1396                 status = ath_tgt_tx_form_aggr(sc, tid, &bf_q);
1397
1398                 if (asf_tailq_empty(&bf_q))
1399                         break;
1400
1401                 bf = asf_tailq_first(&bf_q);
1402                 bf_last = asf_tailq_last(&bf_q, ath_tx_bufhead_s);
1403
1404                 if (bf->bf_nframes == 1) {
1405
1406                         if(bf->bf_retries == 0)
1407                                 __stats(sc, txaggr_single);
1408                         bf->bf_isaggr = 0;
1409                         bf->bf_lastds = &(bf->bf_descarr[bf->bf_dmamap_info.nsegs -1]);
1410                         bf->bf_lastds->ds_link = 0;
1411                         bf->bf_next = NULL;
1412
1413                         for(ds = bf->bf_desc; ds <= bf->bf_lastds; ds++)
1414                                 ah->ah_clr11nAggr(ah, ds);
1415
1416                         ath_buf_set_rate(sc, bf);
1417                         bf->bf_txq_add(sc, bf);
1418
1419                         continue;
1420                 }
1421
1422                 bf_last->bf_next = NULL;
1423                 bf_last->bf_lastds->ds_link = 0;
1424                 bf_last->bf_ndelim = 0;
1425
1426                 bf->bf_isaggr  = 1;
1427                 ath_buf_set_rate(sc, bf);
1428                 ah->ah_set11nAggrFirst(ah, bf->bf_desc, bf->bf_al,
1429                                           bf->bf_ndelim);
1430                 bf->bf_lastds = bf_last->bf_lastds;
1431
1432                 for (i = 0; i < bf_last->bf_dmamap_info.nsegs; i++)
1433                         ah->ah_set11nAggrLast(ah, &bf_last->bf_descarr[i]);
1434
1435                 if (status == ATH_AGGR_8K_LIMITED) {
1436                         adf_os_assert(0);
1437                         break;
1438                 }
1439
1440                 bf->bf_txq_add(sc, bf);
1441         } while (txq->axq_depth < ATH_AGGR_MIN_QDEPTH &&
1442                  status != ATH_TGT_AGGR_BAW_CLOSED);
1443 }
1444
1445 static u_int32_t ath_lookup_rate(struct ath_softc_tgt *sc,
1446                                  struct ath_node_target *an,
1447                                  struct ath_tx_buf *bf)
1448 {
1449         int i, prate;
1450         u_int32_t max4msframelen, frame_length;
1451         u_int16_t aggr_limit, legacy=0;
1452         const HAL_RATE_TABLE  *rt = sc->sc_currates;
1453         struct ieee80211_node_target *ieee_node = (struct ieee80211_node_target *)an;
1454
1455         if (bf->bf_ismcast) {
1456                 bf->bf_rcs[1].tries = bf->bf_rcs[2].tries = bf->bf_rcs[3].tries = 0;
1457                 bf->bf_rcs[0].rix   = 0xb;
1458                 bf->bf_rcs[0].tries = ATH_TXMAXTRY - 1;
1459                 bf->bf_rcs[0].flags = 0;
1460         } else {
1461                 ath_tgt_rate_findrate(sc, an, AH_TRUE, 0, ATH_TXMAXTRY-1, 4, 1,
1462                                       ATH_RC_PROBE_ALLOWED, bf->bf_rcs, &prate);
1463         }
1464
1465         max4msframelen = IEEE80211_AMPDU_LIMIT_MAX;
1466
1467         for (i = 0; i < 4; i++) {
1468                 if (bf->bf_rcs[i].tries) {
1469                         frame_length = bf->bf_rcs[i].max4msframelen;
1470
1471                         if (rt->info[bf->bf_rcs[i].rix].phy != IEEE80211_T_HT) {
1472                                 legacy = 1;
1473                                 break;
1474                         }
1475
1476                         max4msframelen = ATH_MIN(max4msframelen, frame_length);
1477                 }
1478         }
1479
1480         if (prate || legacy)
1481                 return 0;
1482
1483         if (sc->sc_ic.ic_enable_coex)
1484                 aggr_limit = ATH_MIN((max4msframelen*3)/8, sc->sc_ic.ic_ampdu_limit);
1485         else
1486                 aggr_limit = ATH_MIN(max4msframelen, sc->sc_ic.ic_ampdu_limit);
1487
1488         if (ieee_node->ni_maxampdu)
1489                 aggr_limit = ATH_MIN(aggr_limit, ieee_node->ni_maxampdu);
1490
1491         return aggr_limit;
1492 }
1493
1494 int ath_tgt_tx_form_aggr(struct ath_softc_tgt *sc, ath_atx_tid_t *tid,
1495                          ath_tx_bufhead *bf_q)
1496 {
1497         struct ath_tx_buf *bf_first ,*bf_prev = NULL;
1498         int nframes = 0, rl = 0;;
1499         struct ath_tx_desc *ds = NULL;
1500         struct ath_tx_buf *bf;
1501         struct ath_hal *ah = sc->sc_ah;
1502         u_int16_t aggr_limit =  (64*1024 -1), al = 0, bpad = 0, al_delta;
1503         u_int16_t h_baw = tid->baw_size/2, prev_al = 0, prev_frames = 0;
1504
1505         bf_first = asf_tailq_first(&tid->buf_q);
1506
1507         do {
1508                 bf = asf_tailq_first(&tid->buf_q);
1509                 adf_os_assert(bf);
1510
1511                 if (!BAW_WITHIN(tid->seq_start, tid->baw_size,
1512                                 SEQNO_FROM_BF_SEQNO(bf->bf_seqno))) {
1513
1514                         bf_first->bf_al= al;
1515                         bf_first->bf_nframes = nframes;
1516                         return ATH_TGT_AGGR_BAW_CLOSED;
1517                 }
1518
1519                 if (!rl) {
1520                         aggr_limit = ath_lookup_rate(sc, tid->an, bf);
1521                         rl = 1;
1522                 }
1523
1524                 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_pktlen;
1525
1526                 if (nframes && (aggr_limit < (al + bpad + al_delta + prev_al))) {
1527                         bf_first->bf_al= al;
1528                         bf_first->bf_nframes = nframes;
1529                         return ATH_TGT_AGGR_LIMITED;
1530                 }
1531
1532 #ifdef PROJECT_K2
1533                 if ((nframes + prev_frames) >= ATH_MIN((h_baw), 17)) {
1534 #else
1535                 if ((nframes + prev_frames) >= ATH_MIN((h_baw), 22)) {
1536 #endif
1537                         bf_first->bf_al= al;
1538                         bf_first->bf_nframes = nframes;
1539                         return ATH_TGT_AGGR_LIMITED;
1540                 }
1541
1542                 ath_tx_addto_baw(tid, bf);
1543                 asf_tailq_remove(&tid->buf_q, bf, bf_list);
1544                 asf_tailq_insert_tail(bf_q, bf, bf_list);
1545                 nframes ++;
1546
1547                 adf_os_assert(bf);
1548
1549                 adf_os_assert(bf->bf_comp == ath_tgt_tx_comp_aggr);
1550
1551                 al += bpad + al_delta;
1552                 bf->bf_ndelim = ATH_AGGR_GET_NDELIM(bf->bf_pktlen);
1553
1554                 switch (bf->bf_keytype) {
1555                 case HAL_KEY_TYPE_AES:
1556                         bf->bf_ndelim += ATH_AGGR_ENCRYPTDELIM;
1557                         break;
1558                 case HAL_KEY_TYPE_WEP:
1559                 case HAL_KEY_TYPE_TKIP:
1560                         bf->bf_ndelim += 64;
1561                         break;
1562                 case HAL_KEY_TYPE_WAPI:
1563                         bf->bf_ndelim += 12;
1564                         break;
1565                 default:
1566                         break;
1567                 }
1568
1569                 bpad = PADBYTES(al_delta) + (bf->bf_ndelim << 2);
1570
1571                 if (bf_prev) {
1572                         bf_prev->bf_next = bf;
1573                         bf_prev->bf_lastds->ds_link = ATH_BUF_GET_DESC_PHY_ADDR(bf);
1574                 }
1575                 bf_prev = bf;
1576
1577                 for(ds = bf->bf_desc; ds <= bf->bf_lastds; ds++)
1578                         ah->ah_set11nAggrMiddle(ah, ds, bf->bf_ndelim);
1579
1580         } while (!asf_tailq_empty(&tid->buf_q));
1581
1582         bf_first->bf_al= al;
1583         bf_first->bf_nframes = nframes;
1584
1585         return ATH_TGT_AGGR_DONE;
1586 }
1587
1588 void ath_tx_addto_baw(ath_atx_tid_t *tid, struct ath_tx_buf *bf)
1589 {
1590         int index, cindex;
1591
1592         if (bf->bf_isretried) {
1593                 return;
1594         }
1595
1596         index  = ATH_BA_INDEX(tid->seq_start, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1597         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
1598
1599         TX_BUF_BITMAP_SET(tid->tx_buf_bitmap, cindex);
1600
1601         if (index >= ((tid->baw_tail - tid->baw_head) & (ATH_TID_MAX_BUFS - 1))) {
1602                 tid->baw_tail = cindex;
1603                 INCR(tid->baw_tail, ATH_TID_MAX_BUFS);
1604         }
1605 }
1606
1607 void ath_tgt_tx_comp_aggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1608 {
1609         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
1610         ath_atx_tid_t *tid = ATH_AN_2_TID(an, bf->bf_tidno);
1611         struct ath_tx_desc lastds;
1612         struct ath_tx_desc *ds = &lastds;
1613         struct ath_rc_series rcs[4];
1614         u_int16_t seq_st;
1615         u_int32_t *ba;
1616         int ba_index;
1617         int nbad = 0;
1618         int nframes = bf->bf_nframes;
1619         struct ath_tx_buf *bf_next;
1620         ath_tx_bufhead bf_q;
1621         int tx_ok = 1;
1622         struct ath_tx_buf *bar = NULL;
1623         struct ath_txq *txq;
1624
1625         txq = bf->bf_txq;
1626
1627         if (tid->flag & TID_CLEANUP_INPROGRES) {
1628                 ath_tx_comp_cleanup(sc, bf);
1629                 return;
1630         }
1631
1632         adf_os_mem_copy(ds, bf->bf_lastds, sizeof (struct ath_tx_desc));
1633         adf_os_mem_copy(rcs, bf->bf_rcs, sizeof(rcs));
1634
1635         if (ds->ds_txstat.ts_flags == HAL_TX_SW_FILTERED) {
1636                 adf_os_assert(0);
1637                 return;
1638         }
1639
1640         if (!bf->bf_isaggr) {
1641                 ath_tx_comp_unaggr(sc, bf);
1642                 return;
1643         }
1644
1645         __stats(sc, tx_compaggr);
1646
1647         asf_tailq_init(&bf_q);
1648
1649         seq_st =  ATH_DS_BA_SEQ(ds);
1650         ba     =  ATH_DS_BA_BITMAP(ds);
1651         tx_ok  =  (ATH_DS_TX_STATUS(ds) == HAL_OK);
1652
1653         if (ATH_DS_TX_STATUS(ds) & HAL_TXERR_XRETRY) {
1654                 ath_tx_comp_aggr_error(sc, bf, tid);
1655                 return;
1656         }
1657
1658         if (tx_ok && !ATH_DS_TX_BA(ds)) {
1659                 __stats(sc, txaggr_babug);
1660                 adf_os_print("BA Bug?\n");
1661                 ath_tx_comp_aggr_error(sc, bf, tid);
1662                 return;
1663         }
1664
1665         while (bf) {
1666                 ba_index = ATH_BA_INDEX(seq_st, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1667                 bf_next  = bf->bf_next;
1668
1669                 if (tx_ok && ATH_BA_ISSET(ba, ba_index)) {
1670                         __stats(sc, txaggr_compgood);
1671                         ath_tx_update_baw(tid, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1672                         ath_tx_status_update_aggr(sc, bf, ds, rcs, 1);
1673                         ath_tx_freebuf(sc, bf);
1674                 } else {
1675                         ath_tx_retry_subframe(sc, bf, &bf_q, &bar);
1676                         nbad ++;
1677                 }
1678                 bf = bf_next;
1679         }
1680
1681         ath_update_aggr_stats(sc, ds, nframes, nbad);
1682         ath_rate_tx_complete(sc, an, ds, rcs, nframes, nbad);
1683
1684         if (bar) {
1685                 ath_bar_tx(sc, tid, bar);
1686         }
1687
1688         if (!asf_tailq_empty(&bf_q)) {
1689                 __stats(sc, txaggr_prepends);
1690                 TAILQ_INSERTQ_HEAD(&tid->buf_q, &bf_q, bf_list);
1691                 ath_tgt_tx_enqueue(txq, tid);
1692         }
1693 }
1694
1695 static void
1696 ath_tx_comp_aggr_error(struct ath_softc_tgt *sc, struct ath_tx_buf *bf,
1697                        ath_atx_tid_t *tid)
1698 {
1699
1700
1701         struct ath_tx_desc lastds;
1702         struct ath_tx_desc *ds = &lastds;
1703         struct ath_rc_series rcs[4];
1704         struct ath_tx_buf *bar = NULL;
1705         struct ath_tx_buf *bf_next;
1706         int nframes = bf->bf_nframes;
1707         ath_tx_bufhead bf_q;
1708         struct ath_txq *txq;
1709
1710         asf_tailq_init(&bf_q);
1711         txq = bf->bf_txq;
1712
1713         adf_os_mem_copy(ds, bf->bf_lastds, sizeof (struct ath_tx_desc));
1714         adf_os_mem_copy(rcs, bf->bf_rcs, sizeof(rcs));
1715
1716         while (bf) {
1717                 bf_next = bf->bf_next;
1718                 ath_tx_retry_subframe(sc, bf, &bf_q, &bar);
1719                 bf = bf_next;
1720         }
1721
1722         ath_update_aggr_stats(sc, ds, nframes, nframes);
1723         ath_rate_tx_complete(sc, tid->an, ds, rcs, nframes, nframes);
1724
1725         if (bar) {
1726                 ath_bar_tx(sc, tid, bar);
1727         }
1728
1729         if (!asf_tailq_empty(&bf_q)) {
1730                 __stats(sc, txaggr_prepends);
1731                 TAILQ_INSERTQ_HEAD(&tid->buf_q, &bf_q, bf_list);
1732                 ath_tgt_tx_enqueue(txq, tid);
1733         }
1734 }
1735
1736 static void
1737 ath_tx_comp_cleanup(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1738 {
1739
1740         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
1741         ath_atx_tid_t *tid = ATH_AN_2_TID(an, bf->bf_tidno);
1742         struct ath_tx_desc lastds;
1743         struct ath_tx_desc *ds = &lastds;
1744         struct ath_rc_series rcs[4];
1745         u_int16_t seq_st;
1746         u_int32_t *ba;
1747         int ba_index;
1748         int nbad = 0;
1749         int nframes = bf->bf_nframes;
1750         struct ath_tx_buf *bf_next;
1751         int tx_ok = 1;
1752
1753         adf_os_mem_copy(ds, bf->bf_lastds, sizeof (struct ath_tx_desc));
1754         adf_os_mem_copy(rcs, bf->bf_rcs, sizeof(rcs));
1755
1756         seq_st = ATH_DS_BA_SEQ(ds);
1757         ba     = ATH_DS_BA_BITMAP(ds);
1758         tx_ok  = (ATH_DS_TX_STATUS(ds) == HAL_OK);
1759
1760         if (!bf->bf_isaggr) {
1761                 ath_update_stats(sc, bf);
1762
1763                 __stats(sc, tx_compunaggr);
1764
1765                 ath_tx_status_update(sc, bf);
1766
1767                 ath_tx_freebuf(sc, bf);
1768
1769                 if (tid->flag & TID_CLEANUP_INPROGRES) {
1770                         owl_tgt_tid_cleanup(sc, tid);
1771
1772                 }
1773
1774                 return;
1775         }
1776
1777         while (bf) {
1778                 ba_index = ATH_BA_INDEX(seq_st, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1779                 bf_next  = bf->bf_next;
1780
1781                 ath_tx_status_update_aggr(sc, bf, ds, rcs, 0);
1782
1783                 ath_tx_freebuf(sc, bf);
1784
1785                 tid->incomp--;
1786                 if (!tid->incomp) {
1787                         tid->flag  &= ~TID_CLEANUP_INPROGRES;
1788                         ath_aggr_resume_tid(sc, tid);
1789                         break;
1790                 }
1791
1792                 bf = bf_next;
1793         }
1794
1795         ath_update_aggr_stats(sc, ds, nframes, nbad);
1796         ath_rate_tx_complete(sc, an, ds, rcs, nframes, nbad);
1797 }
1798
1799 static void
1800 ath_tx_retry_subframe(struct ath_softc_tgt *sc, struct ath_tx_buf *bf,
1801                       ath_tx_bufhead *bf_q, struct ath_tx_buf **bar)
1802 {
1803
1804         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
1805         ath_atx_tid_t *tid = ATH_AN_2_TID(an, bf->bf_tidno);
1806         struct ath_tx_desc *ds = NULL;
1807         struct ath_hal *ah = sc->sc_ah;
1808         int i = 0;
1809
1810         __stats(sc, txaggr_compretries);
1811
1812         for(ds = bf->bf_desc, i = 0; i < bf->bf_dmamap_info.nsegs; ds++, i++) {
1813                 ah->ah_clr11nAggr(ah, ds);
1814                 ath_hal_set11n_burstduration(sc->sc_ah, ds, 0);
1815                 ath_hal_set11n_virtualmorefrag(sc->sc_ah, ds, 0);
1816         }
1817
1818         if (bf->bf_retries >= OWLMAX_RETRIES) {
1819                 __stats(sc, txaggr_xretries);
1820                 ath_tx_update_baw(tid, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1821                 ath_tx_status_update_aggr(sc, bf, bf->bf_lastds, NULL, 0);
1822
1823                 if (!*bar)
1824                         *bar = bf;
1825                 else
1826                         ath_tx_freebuf(sc, bf);
1827                 return;
1828         }
1829
1830         if (!bf->bf_next) {
1831                 __stats(sc, txaggr_errlast);
1832                 bf = ath_buf_toggle(sc, bf, 1);
1833         } else
1834                 bf->bf_lastds = &(bf->bf_descarr[bf->bf_dmamap_info.nsegs - 1]);
1835
1836         ath_tx_set_retry(sc, bf);
1837         asf_tailq_insert_tail(bf_q, bf, bf_list);
1838 }
1839
1840 static void
1841 ath_update_aggr_stats(struct ath_softc_tgt *sc,
1842                       struct ath_tx_desc *ds, int nframes,
1843                       int nbad)
1844 {
1845
1846         u_int8_t status = ATH_DS_TX_STATUS(ds);
1847         u_int8_t txflags = ATH_DS_TX_FLAGS(ds);
1848
1849         __statsn(sc, txaggr_longretries, ds->ds_txstat.ts_longretry);
1850         __statsn(sc, txaggr_shortretries, ds->ds_txstat.ts_shortretry);
1851
1852         if (txflags & HAL_TX_DESC_CFG_ERR)
1853                 __stats(sc, txaggr_desc_cfgerr);
1854
1855         if (txflags & HAL_TX_DATA_UNDERRUN)
1856                 __stats(sc, txaggr_data_urun);
1857
1858         if (txflags & HAL_TX_DELIM_UNDERRUN)
1859                 __stats(sc, txaggr_delim_urun);
1860
1861         if (!status) {
1862                 return;
1863         }
1864
1865         if (status & HAL_TXERR_XRETRY)
1866                 __stats(sc, txaggr_compxretry);
1867
1868         if (status & HAL_TXERR_FILT)
1869                 __stats(sc, txaggr_filtered);
1870
1871         if (status & HAL_TXERR_FIFO)
1872                 __stats(sc, txaggr_fifo);
1873
1874         if (status & HAL_TXERR_XTXOP)
1875                 __stats(sc, txaggr_xtxop);
1876
1877         if (status & HAL_TXERR_TIMER_EXPIRED)
1878                 __stats(sc, txaggr_timer_exp);
1879 }
1880
1881 static void
1882 ath_tx_comp_unaggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1883 {
1884         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
1885         ath_atx_tid_t *tid = ATH_AN_2_TID(an, bf->bf_tidno);
1886         struct ath_tx_desc *ds  = bf->bf_lastds;
1887
1888         ath_update_stats(sc, bf);
1889         ath_rate_tx_complete(sc, an, ds, bf->bf_rcs, 1, 0);
1890
1891         if (ATH_DS_TX_STATUS(ds) & HAL_TXERR_XRETRY) {
1892                 ath_tx_retry_unaggr(sc, bf);
1893                 return;
1894         }
1895         __stats(sc, tx_compunaggr);
1896
1897         ath_tx_update_baw(tid, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1898         ath_tx_status_update(sc, bf);
1899         ath_tx_freebuf(sc, bf);
1900 }
1901
1902 static inline void
1903 ath_tx_retry_unaggr(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1904 {
1905         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
1906         ath_atx_tid_t *tid = ATH_AN_2_TID(an, bf->bf_tidno);
1907         struct ath_txq *txq;
1908
1909         txq = bf->bf_txq;
1910
1911         if (bf->bf_retries >= OWLMAX_RETRIES) {
1912                 __stats(sc, txunaggr_xretry);
1913                 ath_tx_update_baw(tid, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1914                 ath_tx_status_update(sc, bf);
1915                 ath_bar_tx(sc, tid, bf);
1916                 return;
1917         }
1918
1919         __stats(sc, txunaggr_compretries);
1920         if (!bf->bf_lastds->ds_link) {
1921                 __stats(sc, txunaggr_errlast);
1922                 bf = ath_buf_toggle(sc, bf, 1);
1923         }
1924
1925         ath_tx_set_retry(sc, bf);
1926         asf_tailq_insert_head(&tid->buf_q, bf, bf_list);
1927         ath_tgt_tx_enqueue(txq, tid);
1928 }
1929
1930 static void
1931 ath_tx_update_baw(ath_atx_tid_t *tid, int seqno)
1932 {
1933         int index;
1934         int cindex;
1935
1936         index  = ATH_BA_INDEX(tid->seq_start, seqno);
1937         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
1938
1939         TX_BUF_BITMAP_CLR(tid->tx_buf_bitmap, cindex);
1940
1941         while (tid->baw_head != tid->baw_tail &&
1942                (!TX_BUF_BITMAP_IS_SET(tid->tx_buf_bitmap, tid->baw_head))) {
1943                 INCR(tid->seq_start, IEEE80211_SEQ_MAX);
1944                 INCR(tid->baw_head, ATH_TID_MAX_BUFS);
1945         }
1946 }
1947
1948 static void ath_tx_set_retry(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
1949 {
1950         struct ieee80211_frame *wh;
1951
1952         __stats(sc, txaggr_retries);
1953
1954         bf->bf_isretried = 1;
1955         bf->bf_retries ++;
1956         wh = ATH_SKB_2_WH(bf->bf_skb);
1957         wh->i_fc[1] |= IEEE80211_FC1_RETRY;
1958 }
1959
1960 void ath_tgt_tx_cleanup(struct ath_softc_tgt *sc, struct ath_node_target *an,
1961                         ath_atx_tid_t *tid, a_uint8_t discard_all)
1962 {
1963         struct ath_tx_buf *bf;
1964         struct ath_tx_buf *bf_next;
1965         struct ath_txq *txq;
1966
1967         txq = TID_TO_ACTXQ(tid->tidno);
1968
1969         bf = asf_tailq_first(&tid->buf_q);
1970
1971         while (bf) {
1972                 if (discard_all || bf->bf_isretried) {
1973                         bf_next = asf_tailq_next(bf, bf_list);
1974                         TAILQ_DEQ(&tid->buf_q, bf, bf_list);
1975                         if (bf->bf_isretried)
1976                                 ath_tx_update_baw(tid, SEQNO_FROM_BF_SEQNO(bf->bf_seqno));
1977                         ath_tx_freebuf(sc, bf);
1978                         bf = bf_next;
1979                         continue;
1980                 }
1981                 bf->bf_comp = ath_tgt_tx_comp_normal;
1982                 bf = asf_tailq_next(bf, bf_list);
1983         }
1984
1985         ath_aggr_pause_tid(sc, tid);
1986
1987         while (tid->baw_head != tid->baw_tail) {
1988                 if (TX_BUF_BITMAP_IS_SET(tid->tx_buf_bitmap, tid->baw_head)) {
1989                         tid->incomp++;
1990                         tid->flag |= TID_CLEANUP_INPROGRES;
1991                         TX_BUF_BITMAP_CLR(tid->tx_buf_bitmap, tid->baw_head);
1992                 }
1993                 INCR(tid->baw_head, ATH_TID_MAX_BUFS);
1994                 INCR(tid->seq_start, IEEE80211_SEQ_MAX);
1995         }
1996
1997         if (!(tid->flag & TID_CLEANUP_INPROGRES)) {
1998                 ath_aggr_resume_tid(sc, tid);
1999         }
2000 }
2001
2002 /******************/
2003 /* BAR Management */
2004 /******************/
2005
2006 static void ath_tgt_delba_send(struct ath_softc_tgt *sc,
2007                                struct ieee80211_node_target *ni,
2008                                a_uint8_t tidno, a_uint8_t initiator,
2009                                a_uint16_t reasoncode)
2010 {
2011         struct ath_node_target *an = ATH_NODE_TARGET(ni);
2012         ath_atx_tid_t *tid = ATH_AN_2_TID(an, tidno);
2013         struct wmi_data_delba wmi_delba;
2014
2015         tid->flag &= ~TID_AGGR_ENABLED;
2016
2017         ath_tgt_tx_cleanup(sc, an, tid, 1);
2018
2019         wmi_delba.ni_nodeindex = ni->ni_nodeindex;
2020         wmi_delba.tidno = tid->tidno;
2021         wmi_delba.initiator = 1;
2022         wmi_delba.reasoncode = IEEE80211_REASON_UNSPECIFIED;
2023
2024         __stats(sc, txbar_xretry);
2025         wmi_event(sc->tgt_wmi_handle,
2026                   WMI_DELBA_EVENTID,
2027                   &wmi_delba,
2028                   sizeof(wmi_delba));
2029 }
2030
2031 static void ath_bar_retry(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
2032 {
2033         struct ath_node_target *an = ATH_NODE_TARGET(bf->bf_node);
2034         ath_atx_tid_t *tid = ATH_AN_2_TID(an, bf->bf_tidno);
2035
2036         if (bf->bf_retries >= OWLMAX_BAR_RETRIES) {
2037                 ath_tgt_delba_send(sc, bf->bf_node, tid->tidno, 1,
2038                                    IEEE80211_REASON_UNSPECIFIED);
2039                 ath_tgt_tid_drain(sc, tid);
2040
2041                 bf->bf_comp = NULL;
2042                 ath_buf_comp(sc, bf);
2043                 return;
2044         }
2045
2046         __stats(sc, txbar_compretries);
2047
2048         if (!bf->bf_lastds->ds_link) {
2049                 __stats(sc, txbar_errlast);
2050                 bf = ath_buf_toggle(sc, bf, 1);
2051         }
2052
2053         bf->bf_lastds->ds_link = 0;
2054
2055         ath_tx_set_retry(sc, bf);
2056         ath_tgt_txq_add_ucast(sc, bf);
2057 }
2058
2059 static void ath_bar_tx_comp(struct ath_softc_tgt *sc, struct ath_tx_buf *bf)
2060 {
2061         struct ath_tx_desc *ds = bf->bf_lastds;
2062         struct ath_node_target *an;
2063         ath_atx_tid_t *tid;
2064         struct ath_txq *txq;
2065
2066         an = (struct ath_node_target *)bf->bf_node;
2067         tid = &an->tid[bf->bf_tidno];
2068         txq = TID_TO_ACTXQ(tid->tidno);
2069
2070         if (ATH_DS_TX_STATUS(ds) & HAL_TXERR_XRETRY) {
2071                 ath_bar_retry(sc, bf);
2072                 return;
2073         }
2074
2075         ath_aggr_resume_tid(sc, tid);
2076
2077         bf->bf_comp = NULL;
2078         ath_buf_comp(sc, bf);
2079 }
2080
2081 static void ath_bar_tx(struct ath_softc_tgt *sc,
2082                        ath_atx_tid_t *tid, struct ath_tx_buf *bf)
2083 {
2084         adf_nbuf_t skb;
2085         struct ieee80211_frame_bar *bar;
2086         u_int8_t min_rate;
2087         struct ath_tx_desc *ds, *ds0;
2088         struct ath_hal *ah = sc->sc_ah;
2089         HAL_11N_RATE_SERIES series[4];
2090         int i = 0;
2091         adf_nbuf_queue_t skbhead;
2092         a_uint8_t *anbdata;
2093         a_uint32_t anblen;
2094
2095         __stats(sc, tx_bars);
2096
2097         adf_os_mem_set(&series, 0, sizeof(series));
2098
2099         ath_aggr_pause_tid(sc, tid);
2100
2101         skb = adf_nbuf_queue_remove(&bf->bf_skbhead);
2102         adf_nbuf_peek_header(skb, &anbdata, &anblen);
2103         adf_nbuf_trim_tail(skb, anblen);
2104         bar = (struct ieee80211_frame_bar *) anbdata;
2105
2106         min_rate =  0x0b;
2107
2108         ath_dma_unmap(sc, bf);
2109         adf_nbuf_queue_add(&bf->bf_skbhead, skb);
2110
2111         bar->i_fc[1] = IEEE80211_FC1_DIR_NODS;
2112         bar->i_fc[0] = IEEE80211_FC0_VERSION_0 |
2113                 IEEE80211_FC0_TYPE_CTL |
2114                 IEEE80211_FC0_SUBTYPE_BAR;
2115         bar->i_ctl = tid->tidno << IEEE80211_BAR_CTL_TID_S |
2116                 IEEE80211_BAR_CTL_COMBA;
2117         bar->i_seq = adf_os_cpu_to_le16(tid->seq_start << IEEE80211_SEQ_SEQ_SHIFT);
2118
2119         bf->bf_seqno = tid->seq_start << IEEE80211_SEQ_SEQ_SHIFT;
2120
2121         adf_nbuf_put_tail(skb, sizeof(struct ieee80211_frame_bar));
2122
2123         bf->bf_comp = ath_bar_tx_comp;
2124         bf->bf_tidno = tid->tidno;
2125         bf->bf_node = &tid->an->ni;
2126         ath_dma_map(sc, bf);
2127         adf_nbuf_dmamap_info(bf->bf_dmamap, &bf->bf_dmamap_info);
2128
2129         ds = bf->bf_desc;
2130         ath_hal_setuptxdesc(sc->sc_ah, ds
2131                             , adf_nbuf_len(skb) + IEEE80211_CRC_LEN
2132                             , 0
2133                             , HAL_PKT_TYPE_NORMAL
2134                             , ATH_MIN(60, 60)
2135                             , min_rate
2136                             , ATH_TXMAXTRY
2137                             , bf->bf_keyix
2138                             , 0
2139                             , HAL_TXDESC_INTREQ
2140                             | HAL_TXDESC_CLRDMASK
2141                             , 0, 0, 0, 0
2142                             , ATH_COMP_PROC_NO_COMP_NO_CCS);
2143
2144         skbhead = bf->bf_skbhead;
2145         bf->bf_isaggr = 0;
2146         bf->bf_next = NULL;
2147
2148         for (ds0 = ds, i=0; i < bf->bf_dmamap_info.nsegs; ds0++, i++) {
2149                 ah->ah_clr11nAggr(ah, ds0);
2150         }
2151
2152         ath_filltxdesc(sc, bf);
2153
2154         for (i = 0 ; i < 4; i++) {
2155                 series[i].Tries = ATH_TXMAXTRY;
2156                 series[i].Rate = min_rate;
2157                 series[i].ChSel = sc->sc_ic.ic_tx_chainmask;
2158         }
2159
2160         ah->ah_set11nRateScenario(ah, bf->bf_desc, 0, 0, 0, series, 4, 4);
2161         ath_tgt_txq_add_ucast(sc, bf);
2162 }