Pileus Git - ~andy/linux/blob - drivers/net/wireless/brcm80211/brcmsmac/ampdu.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   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 ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #include <net/mac80211.h>
  17
  18 #include "rate.h"
  19 #include "scb.h"
  20 #include "phy/phy_hal.h"
  21 #include "antsel.h"
  22 #include "main.h"
  23 #include "ampdu.h"
  24
  25 /* max number of mpdus in an ampdu */
  26 #define AMPDU_MAX_MPDU                  32
  27 /* max number of mpdus in an ampdu to a legacy */
  28 #define AMPDU_NUM_MPDU_LEGACY           16
  29 /* max Tx ba window size (in pdu) */
  30 #define AMPDU_TX_BA_MAX_WSIZE           64
  31 /* default Tx ba window size (in pdu) */
  32 #define AMPDU_TX_BA_DEF_WSIZE           64
  33 /* default Rx ba window size (in pdu) */
  34 #define AMPDU_RX_BA_DEF_WSIZE           64
  35 /* max Rx ba window size (in pdu) */
  36 #define AMPDU_RX_BA_MAX_WSIZE           64
  37 /* max dur of tx ampdu (in msec) */
  38 #define AMPDU_MAX_DUR                   5
  39 /* default tx retry limit */
  40 #define AMPDU_DEF_RETRY_LIMIT           5
  41 /* default tx retry limit at reg rate */
  42 #define AMPDU_DEF_RR_RETRY_LIMIT        2
  43 /* default weight of ampdu in txfifo */
  44 #define AMPDU_DEF_TXPKT_WEIGHT          2
  45 /* default ffpld reserved bytes */
  46 #define AMPDU_DEF_FFPLD_RSVD            2048
  47 /* # of inis to be freed on detach */
  48 #define AMPDU_INI_FREE                  10
  49 /* max # of mpdus released at a time */
  50 #define AMPDU_SCB_MAX_RELEASE           20
  51
  52 #define NUM_FFPLD_FIFO 4        /* number of fifo concerned by pre-loading */
  53 #define FFPLD_TX_MAX_UNFL   200 /* default value of the average number of ampdu
  54                                  * without underflows
  55                                  */
  56 #define FFPLD_MPDU_SIZE 1800    /* estimate of maximum mpdu size */
  57 #define FFPLD_MAX_MCS 23        /* we don't deal with mcs 32 */
  58 #define FFPLD_PLD_INCR 1000     /* increments in bytes */
  59 #define FFPLD_MAX_AMPDU_CNT 5000        /* maximum number of ampdu we
  60                                          * accumulate between resets.
  61                                          */
  62
  63 #define AMPDU_DELIMITER_LEN     4
  64
  65 /* max allowed number of mpdus in an ampdu (2 streams) */
  66 #define AMPDU_NUM_MPDU          16
  67
  68 #define TX_SEQ_TO_INDEX(seq) ((seq) % AMPDU_TX_BA_MAX_WSIZE)
  69
  70 /* max possible overhead per mpdu in the ampdu; 3 is for roundup if needed */
  71 #define AMPDU_MAX_MPDU_OVERHEAD (FCS_LEN + DOT11_ICV_AES_LEN +\
  72         AMPDU_DELIMITER_LEN + 3\
  73         + DOT11_A4_HDR_LEN + DOT11_QOS_LEN + DOT11_IV_MAX_LEN)
  74
  75 /* modulo add/sub, bound = 2^k */
  76 #define MODADD_POW2(x, y, bound) (((x) + (y)) & ((bound) - 1))
  77 #define MODSUB_POW2(x, y, bound) (((x) - (y)) & ((bound) - 1))
  78
  79 /* structure to hold tx fifo information and pre-loading state
  80  * counters specific to tx underflows of ampdus
  81  * some counters might be redundant with the ones in wlc or ampdu structures.
  82  * This allows to maintain a specific state independently of
  83  * how often and/or when the wlc counters are updated.
  84  *
  85  * ampdu_pld_size: number of bytes to be pre-loaded
  86  * mcs2ampdu_table: per-mcs max # of mpdus in an ampdu
  87  * prev_txfunfl: num of underflows last read from the HW macstats counter
  88  * accum_txfunfl: num of underflows since we modified pld params
  89  * accum_txampdu: num of tx ampdu since we modified pld params
  90  * prev_txampdu: previous reading of tx ampdu
  91  * dmaxferrate: estimated dma avg xfer rate in kbits/sec
  92  */
  93 struct brcms_fifo_info {
  94         u16 ampdu_pld_size;
  95         u8 mcs2ampdu_table[FFPLD_MAX_MCS + 1];
  96         u16 prev_txfunfl;
  97         u32 accum_txfunfl;
  98         u32 accum_txampdu;
  99         u32 prev_txampdu;
 100         u32 dmaxferrate;
 101 };
 102
 103 /* AMPDU module specific state
 104  *
 105  * wlc: pointer to main wlc structure
 106  * scb_handle: scb cubby handle to retrieve data from scb
 107  * ini_enable: per-tid initiator enable/disable of ampdu
 108  * ba_tx_wsize: Tx ba window size (in pdu)
 109  * ba_rx_wsize: Rx ba window size (in pdu)
 110  * retry_limit: mpdu transmit retry limit
 111  * rr_retry_limit: mpdu transmit retry limit at regular rate
 112  * retry_limit_tid: per-tid mpdu transmit retry limit
 113  * rr_retry_limit_tid: per-tid mpdu transmit retry limit at regular rate
 114  * mpdu_density: min mpdu spacing (0-7) ==> 2^(x-1)/8 usec
 115  * max_pdu: max pdus allowed in ampdu
 116  * dur: max duration of an ampdu (in msec)
 117  * txpkt_weight: weight of ampdu in txfifo; reduces rate lag
 118  * rx_factor: maximum rx ampdu factor (0-3) ==> 2^(13+x) bytes
 119  * ffpld_rsvd: number of bytes to reserve for preload
 120  * max_txlen: max size of ampdu per mcs, bw and sgi
 121  * mfbr: enable multiple fallback rate
 122  * tx_max_funl: underflows should be kept such that
 123  *              (tx_max_funfl*underflows) < tx frames
 124  * fifo_tb: table of fifo infos
 125  */
 126 struct ampdu_info {
 127         struct brcms_c_info *wlc;
 128         int scb_handle;
 129         u8 ini_enable[AMPDU_MAX_SCB_TID];
 130         u8 ba_tx_wsize;
 131         u8 ba_rx_wsize;
 132         u8 retry_limit;
 133         u8 rr_retry_limit;
 134         u8 retry_limit_tid[AMPDU_MAX_SCB_TID];
 135         u8 rr_retry_limit_tid[AMPDU_MAX_SCB_TID];
 136         u8 mpdu_density;
 137         s8 max_pdu;
 138         u8 dur;
 139         u8 txpkt_weight;
 140         u8 rx_factor;
 141         u32 ffpld_rsvd;
 142         u32 max_txlen[MCS_TABLE_SIZE][2][2];
 143         bool mfbr;
 144         u32 tx_max_funl;
 145         struct brcms_fifo_info fifo_tb[NUM_FFPLD_FIFO];
 146 };
 147
 148 /* used for flushing ampdu packets */
 149 struct cb_del_ampdu_pars {
 150         struct ieee80211_sta *sta;
 151         u16 tid;
 152 };
 153
 154 static void brcms_c_scb_ampdu_update_max_txlen(struct ampdu_info *ampdu, u8 dur)
 155 {
 156         u32 rate, mcs;
 157
 158         for (mcs = 0; mcs < MCS_TABLE_SIZE; mcs++) {
 159                 /* rate is in Kbps; dur is in msec ==> len = (rate * dur) / 8 */
 160                 /* 20MHz, No SGI */
 161                 rate = mcs_2_rate(mcs, false, false);
 162                 ampdu->max_txlen[mcs][0][0] = (rate * dur) >> 3;
 163                 /* 40 MHz, No SGI */
 164                 rate = mcs_2_rate(mcs, true, false);
 165                 ampdu->max_txlen[mcs][1][0] = (rate * dur) >> 3;
 166                 /* 20MHz, SGI */
 167                 rate = mcs_2_rate(mcs, false, true);
 168                 ampdu->max_txlen[mcs][0][1] = (rate * dur) >> 3;
 169                 /* 40 MHz, SGI */
 170                 rate = mcs_2_rate(mcs, true, true);
 171                 ampdu->max_txlen[mcs][1][1] = (rate * dur) >> 3;
 172         }
 173 }
 174
 175 static bool brcms_c_ampdu_cap(struct ampdu_info *ampdu)
 176 {
 177         if (BRCMS_PHY_11N_CAP(ampdu->wlc->band))
 178                 return true;
 179         else
 180                 return false;
 181 }
 182
 183 static int brcms_c_ampdu_set(struct ampdu_info *ampdu, bool on)
 184 {
 185         struct brcms_c_info *wlc = ampdu->wlc;
 186
 187         wlc->pub->_ampdu = false;
 188
 189         if (on) {
 190                 if (!(wlc->pub->_n_enab & SUPPORT_11N)) {
 191                         wiphy_err(ampdu->wlc->wiphy, "wl%d: driver not "
 192                                 "nmode enabled\n", wlc->pub->unit);
 193                         return -ENOTSUPP;
 194                 }
 195                 if (!brcms_c_ampdu_cap(ampdu)) {
 196                         wiphy_err(ampdu->wlc->wiphy, "wl%d: device not "
 197                                 "ampdu capable\n", wlc->pub->unit);
 198                         return -ENOTSUPP;
 199                 }
 200                 wlc->pub->_ampdu = on;
 201         }
 202
 203         return 0;
 204 }
 205
 206 static void brcms_c_ffpld_init(struct ampdu_info *ampdu)
 207 {
 208         int i, j;
 209         struct brcms_fifo_info *fifo;
 210
 211         for (j = 0; j < NUM_FFPLD_FIFO; j++) {
 212                 fifo = (ampdu->fifo_tb + j);
 213                 fifo->ampdu_pld_size = 0;
 214                 for (i = 0; i <= FFPLD_MAX_MCS; i++)
 215                         fifo->mcs2ampdu_table[i] = 255;
 216                 fifo->dmaxferrate = 0;
 217                 fifo->accum_txampdu = 0;
 218                 fifo->prev_txfunfl = 0;
 219                 fifo->accum_txfunfl = 0;
 220
 221         }
 222 }
 223
 224 struct ampdu_info *brcms_c_ampdu_attach(struct brcms_c_info *wlc)
 225 {
 226         struct ampdu_info *ampdu;
 227         int i;
 228
 229         ampdu = kzalloc(sizeof(struct ampdu_info), GFP_ATOMIC);
 230         if (!ampdu)
 231                 return NULL;
 232
 233         ampdu->wlc = wlc;
 234
 235         for (i = 0; i < AMPDU_MAX_SCB_TID; i++)
 236                 ampdu->ini_enable[i] = true;
 237         /* Disable ampdu for VO by default */
 238         ampdu->ini_enable[PRIO_8021D_VO] = false;
 239         ampdu->ini_enable[PRIO_8021D_NC] = false;
 240
 241         /* Disable ampdu for BK by default since not enough fifo space */
 242         ampdu->ini_enable[PRIO_8021D_NONE] = false;
 243         ampdu->ini_enable[PRIO_8021D_BK] = false;
 244
 245         ampdu->ba_tx_wsize = AMPDU_TX_BA_DEF_WSIZE;
 246         ampdu->ba_rx_wsize = AMPDU_RX_BA_DEF_WSIZE;
 247         ampdu->mpdu_density = AMPDU_DEF_MPDU_DENSITY;
 248         ampdu->max_pdu = AUTO;
 249         ampdu->dur = AMPDU_MAX_DUR;
 250         ampdu->txpkt_weight = AMPDU_DEF_TXPKT_WEIGHT;
 251
 252         ampdu->ffpld_rsvd = AMPDU_DEF_FFPLD_RSVD;
 253         /*
 254          * bump max ampdu rcv size to 64k for all 11n
 255          * devices except 4321A0 and 4321A1
 256          */
 257         if (BRCMS_ISNPHY(wlc->band) && NREV_LT(wlc->band->phyrev, 2))
 258                 ampdu->rx_factor = IEEE80211_HT_MAX_AMPDU_32K;
 259         else
 260                 ampdu->rx_factor = IEEE80211_HT_MAX_AMPDU_64K;
 261         ampdu->retry_limit = AMPDU_DEF_RETRY_LIMIT;
 262         ampdu->rr_retry_limit = AMPDU_DEF_RR_RETRY_LIMIT;
 263
 264         for (i = 0; i < AMPDU_MAX_SCB_TID; i++) {
 265                 ampdu->retry_limit_tid[i] = ampdu->retry_limit;
 266                 ampdu->rr_retry_limit_tid[i] = ampdu->rr_retry_limit;
 267         }
 268
 269         brcms_c_scb_ampdu_update_max_txlen(ampdu, ampdu->dur);
 270         ampdu->mfbr = false;
 271         /* try to set ampdu to the default value */
 272         brcms_c_ampdu_set(ampdu, wlc->pub->_ampdu);
 273
 274         ampdu->tx_max_funl = FFPLD_TX_MAX_UNFL;
 275         brcms_c_ffpld_init(ampdu);
 276
 277         return ampdu;
 278 }
 279
 280 void brcms_c_ampdu_detach(struct ampdu_info *ampdu)
 281 {
 282         kfree(ampdu);
 283 }
 284
 285 static void brcms_c_scb_ampdu_update_config(struct ampdu_info *ampdu,
 286                                             struct scb *scb)
 287 {
 288         struct scb_ampdu *scb_ampdu = &scb->scb_ampdu;
 289         int i;
 290
 291         scb_ampdu->max_pdu = AMPDU_NUM_MPDU;
 292
 293         /* go back to legacy size if some preloading is occurring */
 294         for (i = 0; i < NUM_FFPLD_FIFO; i++) {
 295                 if (ampdu->fifo_tb[i].ampdu_pld_size > FFPLD_PLD_INCR)
 296                         scb_ampdu->max_pdu = AMPDU_NUM_MPDU_LEGACY;
 297         }
 298
 299         /* apply user override */
 300         if (ampdu->max_pdu != AUTO)
 301                 scb_ampdu->max_pdu = (u8) ampdu->max_pdu;
 302
 303         scb_ampdu->release = min_t(u8, scb_ampdu->max_pdu,
 304                                    AMPDU_SCB_MAX_RELEASE);
 305
 306         if (scb_ampdu->max_rx_ampdu_bytes)
 307                 scb_ampdu->release = min_t(u8, scb_ampdu->release,
 308                         scb_ampdu->max_rx_ampdu_bytes / 1600);
 309
 310         scb_ampdu->release = min(scb_ampdu->release,
 311                                  ampdu->fifo_tb[TX_AC_BE_FIFO].
 312                                  mcs2ampdu_table[FFPLD_MAX_MCS]);
 313 }
 314
 315 static void brcms_c_scb_ampdu_update_config_all(struct ampdu_info *ampdu)
 316 {
 317         brcms_c_scb_ampdu_update_config(ampdu, &ampdu->wlc->pri_scb);
 318 }
 319
 320 static void brcms_c_ffpld_calc_mcs2ampdu_table(struct ampdu_info *ampdu, int f)
 321 {
 322         int i;
 323         u32 phy_rate, dma_rate, tmp;
 324         u8 max_mpdu;
 325         struct brcms_fifo_info *fifo = (ampdu->fifo_tb + f);
 326
 327         /* recompute the dma rate */
 328         /* note : we divide/multiply by 100 to avoid integer overflows */
 329         max_mpdu = min_t(u8, fifo->mcs2ampdu_table[FFPLD_MAX_MCS],
 330                          AMPDU_NUM_MPDU_LEGACY);
 331         phy_rate = mcs_2_rate(FFPLD_MAX_MCS, true, false);
 332         dma_rate =
 333             (((phy_rate / 100) *
 334               (max_mpdu * FFPLD_MPDU_SIZE - fifo->ampdu_pld_size))
 335              / (max_mpdu * FFPLD_MPDU_SIZE)) * 100;
 336         fifo->dmaxferrate = dma_rate;
 337
 338         /* fill up the mcs2ampdu table; do not recalc the last mcs */
 339         dma_rate = dma_rate >> 7;
 340         for (i = 0; i < FFPLD_MAX_MCS; i++) {
 341                 /* shifting to keep it within integer range */
 342                 phy_rate = mcs_2_rate(i, true, false) >> 7;
 343                 if (phy_rate > dma_rate) {
 344                         tmp = ((fifo->ampdu_pld_size * phy_rate) /
 345                                ((phy_rate - dma_rate) * FFPLD_MPDU_SIZE)) + 1;
 346                         tmp = min_t(u32, tmp, 255);
 347                         fifo->mcs2ampdu_table[i] = (u8) tmp;
 348                 }
 349         }
 350 }
 351
 352 /* evaluate the dma transfer rate using the tx underflows as feedback.
 353  * If necessary, increase tx fifo preloading. If not enough,
 354  * decrease maximum ampdu size for each mcs till underflows stop
 355  * Return 1 if pre-loading not active, -1 if not an underflow event,
 356  * 0 if pre-loading module took care of the event.
 357  */
 358 static int brcms_c_ffpld_check_txfunfl(struct brcms_c_info *wlc, int fid)
 359 {
 360         struct ampdu_info *ampdu = wlc->ampdu;
 361         u32 phy_rate = mcs_2_rate(FFPLD_MAX_MCS, true, false);
 362         u32 txunfl_ratio;
 363         u8 max_mpdu;
 364         u32 current_ampdu_cnt = 0;
 365         u16 max_pld_size;
 366         u32 new_txunfl;
 367         struct brcms_fifo_info *fifo = (ampdu->fifo_tb + fid);
 368         uint xmtfifo_sz;
 369         u16 cur_txunfl;
 370
 371         /* return if we got here for a different reason than underflows */
 372         cur_txunfl = brcms_b_read_shm(wlc->hw,
 373                                       M_UCODE_MACSTAT +
 374                                       offsetof(struct macstat, txfunfl[fid]));
 375         new_txunfl = (u16) (cur_txunfl - fifo->prev_txfunfl);
 376         if (new_txunfl == 0) {
 377                 BCMMSG(wlc->wiphy, "TX status FRAG set but no tx underflows\n");
 378                 return -1;
 379         }
 380         fifo->prev_txfunfl = cur_txunfl;
 381
 382         if (!ampdu->tx_max_funl)
 383                 return 1;
 384
 385         /* check if fifo is big enough */
 386         if (brcms_b_xmtfifo_sz_get(wlc->hw, fid, &xmtfifo_sz))
 387                 return -1;
 388
 389         if ((TXFIFO_SIZE_UNIT * (u32) xmtfifo_sz) <= ampdu->ffpld_rsvd)
 390                 return 1;
 391
 392         max_pld_size = TXFIFO_SIZE_UNIT * xmtfifo_sz - ampdu->ffpld_rsvd;
 393         fifo->accum_txfunfl += new_txunfl;
 394
 395         /* we need to wait for at least 10 underflows */
 396         if (fifo->accum_txfunfl < 10)
 397                 return 0;
 398
 399         BCMMSG(wlc->wiphy, "ampdu_count %d  tx_underflows %d\n",
 400                 current_ampdu_cnt, fifo->accum_txfunfl);
 401
 402         /*
 403            compute the current ratio of tx unfl per ampdu.
 404            When the current ampdu count becomes too
 405            big while the ratio remains small, we reset
 406            the current count in order to not
 407            introduce too big of a latency in detecting a
 408            large amount of tx underflows later.
 409          */
 410
 411         txunfl_ratio = current_ampdu_cnt / fifo->accum_txfunfl;
 412
 413         if (txunfl_ratio > ampdu->tx_max_funl) {
 414                 if (current_ampdu_cnt >= FFPLD_MAX_AMPDU_CNT)
 415                         fifo->accum_txfunfl = 0;
 416
 417                 return 0;
 418         }
 419         max_mpdu = min_t(u8, fifo->mcs2ampdu_table[FFPLD_MAX_MCS],
 420                          AMPDU_NUM_MPDU_LEGACY);
 421
 422         /* In case max value max_pdu is already lower than
 423            the fifo depth, there is nothing more we can do.
 424          */
 425
 426         if (fifo->ampdu_pld_size >= max_mpdu * FFPLD_MPDU_SIZE) {
 427                 fifo->accum_txfunfl = 0;
 428                 return 0;
 429         }
 430
 431         if (fifo->ampdu_pld_size < max_pld_size) {
 432
 433                 /* increment by TX_FIFO_PLD_INC bytes */
 434                 fifo->ampdu_pld_size += FFPLD_PLD_INCR;
 435                 if (fifo->ampdu_pld_size > max_pld_size)
 436                         fifo->ampdu_pld_size = max_pld_size;
 437
 438                 /* update scb release size */
 439                 brcms_c_scb_ampdu_update_config_all(ampdu);
 440
 441                 /*
 442                  * compute a new dma xfer rate for max_mpdu @ max mcs.
 443                  * This is the minimum dma rate that can achieve no
 444                  * underflow condition for the current mpdu size.
 445                  *
 446                  * note : we divide/multiply by 100 to avoid integer overflows
 447                  */
 448                 fifo->dmaxferrate =
 449                     (((phy_rate / 100) *
 450                       (max_mpdu * FFPLD_MPDU_SIZE - fifo->ampdu_pld_size))
 451                      / (max_mpdu * FFPLD_MPDU_SIZE)) * 100;
 452
 453                 BCMMSG(wlc->wiphy, "DMA estimated transfer rate %d; "
 454                         "pre-load size %d\n",
 455                         fifo->dmaxferrate, fifo->ampdu_pld_size);
 456         } else {
 457
 458                 /* decrease ampdu size */
 459                 if (fifo->mcs2ampdu_table[FFPLD_MAX_MCS] > 1) {
 460                         if (fifo->mcs2ampdu_table[FFPLD_MAX_MCS] == 255)
 461                                 fifo->mcs2ampdu_table[FFPLD_MAX_MCS] =
 462                                     AMPDU_NUM_MPDU_LEGACY - 1;
 463                         else
 464                                 fifo->mcs2ampdu_table[FFPLD_MAX_MCS] -= 1;
 465
 466                         /* recompute the table */
 467                         brcms_c_ffpld_calc_mcs2ampdu_table(ampdu, fid);
 468
 469                         /* update scb release size */
 470                         brcms_c_scb_ampdu_update_config_all(ampdu);
 471                 }
 472         }
 473         fifo->accum_txfunfl = 0;
 474         return 0;
 475 }
 476
 477 void
 478 brcms_c_ampdu_tx_operational(struct brcms_c_info *wlc, u8 tid,
 479         u8 ba_wsize,            /* negotiated ba window size (in pdu) */
 480         uint max_rx_ampdu_bytes) /* from ht_cap in beacon */
 481 {
 482         struct scb_ampdu *scb_ampdu;
 483         struct scb_ampdu_tid_ini *ini;
 484         struct ampdu_info *ampdu = wlc->ampdu;
 485         struct scb *scb = &wlc->pri_scb;
 486         scb_ampdu = &scb->scb_ampdu;
 487
 488         if (!ampdu->ini_enable[tid]) {
 489                 wiphy_err(ampdu->wlc->wiphy, "%s: Rejecting tid %d\n",
 490                           __func__, tid);
 491                 return;
 492         }
 493
 494         ini = &scb_ampdu->ini[tid];
 495         ini->tid = tid;
 496         ini->scb = scb_ampdu->scb;
 497         ini->ba_wsize = ba_wsize;
 498         scb_ampdu->max_rx_ampdu_bytes = max_rx_ampdu_bytes;
 499 }
 500
 501 int
 502 brcms_c_sendampdu(struct ampdu_info *ampdu, struct brcms_txq_info *qi,
 503               struct sk_buff **pdu, int prec)
 504 {
 505         struct brcms_c_info *wlc;
 506         struct sk_buff *p, *pkt[AMPDU_MAX_MPDU];
 507         u8 tid, ndelim;
 508         int err = 0;
 509         u8 preamble_type = BRCMS_GF_PREAMBLE;
 510         u8 fbr_preamble_type = BRCMS_GF_PREAMBLE;
 511         u8 rts_preamble_type = BRCMS_LONG_PREAMBLE;
 512         u8 rts_fbr_preamble_type = BRCMS_LONG_PREAMBLE;
 513
 514         bool rr = true, fbr = false;
 515         uint i, count = 0, fifo, seg_cnt = 0;
 516         u16 plen, len, seq = 0, mcl, mch, index, frameid, dma_len = 0;
 517         u32 ampdu_len, max_ampdu_bytes = 0;
 518         struct d11txh *txh = NULL;
 519         u8 *plcp;
 520         struct ieee80211_hdr *h;
 521         struct scb *scb;
 522         struct scb_ampdu *scb_ampdu;
 523         struct scb_ampdu_tid_ini *ini;
 524         u8 mcs = 0;
 525         bool use_rts = false, use_cts = false;
 526         u32 rspec = 0, rspec_fallback = 0;
 527         u32 rts_rspec = 0, rts_rspec_fallback = 0;
 528         u16 mimo_ctlchbw = PHY_TXC1_BW_20MHZ;
 529         struct ieee80211_rts *rts;
 530         u8 rr_retry_limit;
 531         struct brcms_fifo_info *f;
 532         bool fbr_iscck;
 533         struct ieee80211_tx_info *tx_info;
 534         u16 qlen;
 535         struct wiphy *wiphy;
 536
 537         wlc = ampdu->wlc;
 538         wiphy = wlc->wiphy;
 539         p = *pdu;
 540
 541         tid = (u8) (p->priority);
 542
 543         f = ampdu->fifo_tb + prio2fifo[tid];
 544
 545         scb = &wlc->pri_scb;
 546         scb_ampdu = &scb->scb_ampdu;
 547         ini = &scb_ampdu->ini[tid];
 548
 549         /* Let pressure continue to build ... */
 550         qlen = pktq_plen(&qi->q, prec);
 551         if (ini->tx_in_transit > 0 &&
 552             qlen < min(scb_ampdu->max_pdu, ini->ba_wsize))
 553                 /* Collect multiple MPDU's to be sent in the next AMPDU */
 554                 return -EBUSY;
 555
 556         /* at this point we intend to transmit an AMPDU */
 557         rr_retry_limit = ampdu->rr_retry_limit_tid[tid];
 558         ampdu_len = 0;
 559         dma_len = 0;
 560         while (p) {
 561                 struct ieee80211_tx_rate *txrate;
 562
 563                 tx_info = IEEE80211_SKB_CB(p);
 564                 txrate = tx_info->status.rates;
 565
 566                 if (tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
 567                         err = brcms_c_prep_pdu(wlc, p, &fifo);
 568                 } else {
 569                         wiphy_err(wiphy, "%s: AMPDU flag is off!\n", __func__);
 570                         *pdu = NULL;
 571                         err = 0;
 572                         break;
 573                 }
 574
 575                 if (err) {
 576                         if (err == -EBUSY) {
 577                                 wiphy_err(wiphy, "wl%d: sendampdu: "
 578                                           "prep_xdu retry; seq 0x%x\n",
 579                                           wlc->pub->unit, seq);
 580                                 *pdu = p;
 581                                 break;
 582                         }
 583
 584                         /* error in the packet; reject it */
 585                         wiphy_err(wiphy, "wl%d: sendampdu: prep_xdu "
 586                                   "rejected; seq 0x%x\n", wlc->pub->unit, seq);
 587                         *pdu = NULL;
 588                         break;
 589                 }
 590
 591                 /* pkt is good to be aggregated */
 592                 txh = (struct d11txh *) p->data;
 593                 plcp = (u8 *) (txh + 1);
 594                 h = (struct ieee80211_hdr *)(plcp + D11_PHY_HDR_LEN);
 595                 seq = le16_to_cpu(h->seq_ctrl) >> SEQNUM_SHIFT;
 596                 index = TX_SEQ_TO_INDEX(seq);
 597
 598                 /* check mcl fields and test whether it can be agg'd */
 599                 mcl = le16_to_cpu(txh->MacTxControlLow);
 600                 mcl &= ~TXC_AMPDU_MASK;
 601                 fbr_iscck = !(le16_to_cpu(txh->XtraFrameTypes) & 0x3);
 602                 txh->PreloadSize = 0;   /* always default to 0 */
 603
 604                 /*  Handle retry limits */
 605                 if (txrate[0].count <= rr_retry_limit) {
 606                         txrate[0].count++;
 607                         rr = true;
 608                         fbr = false;
 609                 } else {
 610                         fbr = true;
 611                         rr = false;
 612                         txrate[1].count++;
 613                 }
 614
 615                 /* extract the length info */
 616                 len = fbr_iscck ? BRCMS_GET_CCK_PLCP_LEN(txh->FragPLCPFallback)
 617                     : BRCMS_GET_MIMO_PLCP_LEN(txh->FragPLCPFallback);
 618
 619                 /* retrieve null delimiter count */
 620                 ndelim = txh->RTSPLCPFallback[AMPDU_FBR_NULL_DELIM];
 621                 seg_cnt += 1;
 622
 623                 BCMMSG(wlc->wiphy, "wl%d: mpdu %d plcp_len %d\n",
 624                         wlc->pub->unit, count, len);
 625
 626                 /*
 627                  * aggregateable mpdu. For ucode/hw agg,
 628                  * test whether need to break or change the epoch
 629                  */
 630                 if (count == 0) {
 631                         mcl |= (TXC_AMPDU_FIRST << TXC_AMPDU_SHIFT);
 632                         /* refill the bits since might be a retx mpdu */
 633                         mcl |= TXC_STARTMSDU;
 634                         rts = (struct ieee80211_rts *)&txh->rts_frame;
 635
 636                         if (ieee80211_is_rts(rts->frame_control)) {
 637                                 mcl |= TXC_SENDRTS;
 638                                 use_rts = true;
 639                         }
 640                         if (ieee80211_is_cts(rts->frame_control)) {
 641                                 mcl |= TXC_SENDCTS;
 642                                 use_cts = true;
 643                         }
 644                 } else {
 645                         mcl |= (TXC_AMPDU_MIDDLE << TXC_AMPDU_SHIFT);
 646                         mcl &= ~(TXC_STARTMSDU | TXC_SENDRTS | TXC_SENDCTS);
 647                 }
 648
 649                 len = roundup(len, 4);
 650                 ampdu_len += (len + (ndelim + 1) * AMPDU_DELIMITER_LEN);
 651
 652                 dma_len += (u16) p->len;
 653
 654                 BCMMSG(wlc->wiphy, "wl%d: ampdu_len %d"
 655                         " seg_cnt %d null delim %d\n",
 656                         wlc->pub->unit, ampdu_len, seg_cnt, ndelim);
 657
 658                 txh->MacTxControlLow = cpu_to_le16(mcl);
 659
 660                 /* this packet is added */
 661                 pkt[count++] = p;
 662
 663                 /* patch the first MPDU */
 664                 if (count == 1) {
 665                         u8 plcp0, plcp3, is40, sgi;
 666
 667                         if (rr) {
 668                                 plcp0 = plcp[0];
 669                                 plcp3 = plcp[3];
 670                         } else {
 671                                 plcp0 = txh->FragPLCPFallback[0];
 672                                 plcp3 = txh->FragPLCPFallback[3];
 673
 674                         }
 675                         is40 = (plcp0 & MIMO_PLCP_40MHZ) ? 1 : 0;
 676                         sgi = plcp3_issgi(plcp3) ? 1 : 0;
 677                         mcs = plcp0 & ~MIMO_PLCP_40MHZ;
 678                         max_ampdu_bytes =
 679                             min(scb_ampdu->max_rx_ampdu_bytes,
 680                                 ampdu->max_txlen[mcs][is40][sgi]);
 681
 682                         if (is40)
 683                                 mimo_ctlchbw =
 684                                    CHSPEC_SB_UPPER(wlc_phy_chanspec_get(
 685                                                                  wlc->band->pi))
 686                                    ? PHY_TXC1_BW_20MHZ_UP : PHY_TXC1_BW_20MHZ;
 687
 688                         /* rebuild the rspec and rspec_fallback */
 689                         rspec = RSPEC_MIMORATE;
 690                         rspec |= plcp[0] & ~MIMO_PLCP_40MHZ;
 691                         if (plcp[0] & MIMO_PLCP_40MHZ)
 692                                 rspec |= (PHY_TXC1_BW_40MHZ << RSPEC_BW_SHIFT);
 693
 694                         if (fbr_iscck)  /* CCK */
 695                                 rspec_fallback = cck_rspec(cck_phy2mac_rate
 696                                                     (txh->FragPLCPFallback[0]));
 697                         else {  /* MIMO */
 698                                 rspec_fallback = RSPEC_MIMORATE;
 699                                 rspec_fallback |=
 700                                     txh->FragPLCPFallback[0] & ~MIMO_PLCP_40MHZ;
 701                                 if (txh->FragPLCPFallback[0] & MIMO_PLCP_40MHZ)
 702                                         rspec_fallback |=
 703                                             (PHY_TXC1_BW_40MHZ <<
 704                                              RSPEC_BW_SHIFT);
 705                         }
 706
 707                         if (use_rts || use_cts) {
 708                                 rts_rspec =
 709                                     brcms_c_rspec_to_rts_rspec(wlc,
 710                                         rspec, false, mimo_ctlchbw);
 711                                 rts_rspec_fallback =
 712                                     brcms_c_rspec_to_rts_rspec(wlc,
 713                                         rspec_fallback, false, mimo_ctlchbw);
 714                         }
 715                 }
 716
 717                 /* if (first mpdu for host agg) */
 718                 /* test whether to add more */
 719                 if ((mcs_2_rate(mcs, true, false) >= f->dmaxferrate) &&
 720                     (count == f->mcs2ampdu_table[mcs])) {
 721                         BCMMSG(wlc->wiphy, "wl%d: PR 37644: stopping"
 722                                 " ampdu at %d for mcs %d\n",
 723                                 wlc->pub->unit, count, mcs);
 724                         break;
 725                 }
 726
 727                 if (count == scb_ampdu->max_pdu)
 728                         break;
 729
 730                 /*
 731                  * check to see if the next pkt is
 732                  * a candidate for aggregation
 733                  */
 734                 p = pktq_ppeek(&qi->q, prec);
 735                 if (p) {
 736                         tx_info = IEEE80211_SKB_CB(p);
 737                         if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) &&
 738                             ((u8) (p->priority) == tid)) {
 739                                 plen = p->len + AMPDU_MAX_MPDU_OVERHEAD;
 740                                 plen = max(scb_ampdu->min_len, plen);
 741
 742                                 if ((plen + ampdu_len) > max_ampdu_bytes) {
 743                                         p = NULL;
 744                                         continue;
 745                                 }
 746
 747                                 /*
 748                                  * check if there are enough
 749                                  * descriptors available
 750                                  */
 751                                 if (*wlc->core->txavail[fifo] <= seg_cnt + 1) {
 752                                         wiphy_err(wiphy, "%s: No fifo space  "
 753                                                   "!!\n", __func__);
 754                                         p = NULL;
 755                                         continue;
 756                                 }
 757                                 /* next packet fit for aggregation so dequeue */
 758                                 p = brcmu_pktq_pdeq(&qi->q, prec);
 759                         } else {
 760                                 p = NULL;
 761                         }
 762                 }
 763         }                       /* end while(p) */
 764
 765         ini->tx_in_transit += count;
 766
 767         if (count) {
 768                 /* patch up the last txh */
 769                 txh = (struct d11txh *) pkt[count - 1]->data;
 770                 mcl = le16_to_cpu(txh->MacTxControlLow);
 771                 mcl &= ~TXC_AMPDU_MASK;
 772                 mcl |= (TXC_AMPDU_LAST << TXC_AMPDU_SHIFT);
 773                 txh->MacTxControlLow = cpu_to_le16(mcl);
 774
 775                 /* remove the null delimiter after last mpdu */
 776                 ndelim = txh->RTSPLCPFallback[AMPDU_FBR_NULL_DELIM];
 777                 txh->RTSPLCPFallback[AMPDU_FBR_NULL_DELIM] = 0;
 778                 ampdu_len -= ndelim * AMPDU_DELIMITER_LEN;
 779
 780                 /* remove the pad len from last mpdu */
 781                 fbr_iscck = ((le16_to_cpu(txh->XtraFrameTypes) & 0x3) == 0);
 782                 len = fbr_iscck ? BRCMS_GET_CCK_PLCP_LEN(txh->FragPLCPFallback)
 783                     : BRCMS_GET_MIMO_PLCP_LEN(txh->FragPLCPFallback);
 784                 ampdu_len -= roundup(len, 4) - len;
 785
 786                 /* patch up the first txh & plcp */
 787                 txh = (struct d11txh *) pkt[0]->data;
 788                 plcp = (u8 *) (txh + 1);
 789
 790                 BRCMS_SET_MIMO_PLCP_LEN(plcp, ampdu_len);
 791                 /* mark plcp to indicate ampdu */
 792                 BRCMS_SET_MIMO_PLCP_AMPDU(plcp);
 793
 794                 /* reset the mixed mode header durations */
 795                 if (txh->MModeLen) {
 796                         u16 mmodelen =
 797                             brcms_c_calc_lsig_len(wlc, rspec, ampdu_len);
 798                         txh->MModeLen = cpu_to_le16(mmodelen);
 799                         preamble_type = BRCMS_MM_PREAMBLE;
 800                 }
 801                 if (txh->MModeFbrLen) {
 802                         u16 mmfbrlen =
 803                             brcms_c_calc_lsig_len(wlc, rspec_fallback,
 804                                                   ampdu_len);
 805                         txh->MModeFbrLen = cpu_to_le16(mmfbrlen);
 806                         fbr_preamble_type = BRCMS_MM_PREAMBLE;
 807                 }
 808
 809                 /* set the preload length */
 810                 if (mcs_2_rate(mcs, true, false) >= f->dmaxferrate) {
 811                         dma_len = min(dma_len, f->ampdu_pld_size);
 812                         txh->PreloadSize = cpu_to_le16(dma_len);
 813                 } else
 814                         txh->PreloadSize = 0;
 815
 816                 mch = le16_to_cpu(txh->MacTxControlHigh);
 817
 818                 /* update RTS dur fields */
 819                 if (use_rts || use_cts) {
 820                         u16 durid;
 821                         rts = (struct ieee80211_rts *)&txh->rts_frame;
 822                         if ((mch & TXC_PREAMBLE_RTS_MAIN_SHORT) ==
 823                             TXC_PREAMBLE_RTS_MAIN_SHORT)
 824                                 rts_preamble_type = BRCMS_SHORT_PREAMBLE;
 825
 826                         if ((mch & TXC_PREAMBLE_RTS_FB_SHORT) ==
 827                             TXC_PREAMBLE_RTS_FB_SHORT)
 828                                 rts_fbr_preamble_type = BRCMS_SHORT_PREAMBLE;
 829
 830                         durid =
 831                             brcms_c_compute_rtscts_dur(wlc, use_cts, rts_rspec,
 832                                                    rspec, rts_preamble_type,
 833                                                    preamble_type, ampdu_len,
 834                                                    true);
 835                         rts->duration = cpu_to_le16(durid);
 836                         durid = brcms_c_compute_rtscts_dur(wlc, use_cts,
 837                                                        rts_rspec_fallback,
 838                                                        rspec_fallback,
 839                                                        rts_fbr_preamble_type,
 840                                                        fbr_preamble_type,
 841                                                        ampdu_len, true);
 842                         txh->RTSDurFallback = cpu_to_le16(durid);
 843                         /* set TxFesTimeNormal */
 844                         txh->TxFesTimeNormal = rts->duration;
 845                         /* set fallback rate version of TxFesTimeNormal */
 846                         txh->TxFesTimeFallback = txh->RTSDurFallback;
 847                 }
 848
 849                 /* set flag and plcp for fallback rate */
 850                 if (fbr) {
 851                         mch |= TXC_AMPDU_FBR;
 852                         txh->MacTxControlHigh = cpu_to_le16(mch);
 853                         BRCMS_SET_MIMO_PLCP_AMPDU(plcp);
 854                         BRCMS_SET_MIMO_PLCP_AMPDU(txh->FragPLCPFallback);
 855                 }
 856
 857                 BCMMSG(wlc->wiphy, "wl%d: count %d ampdu_len %d\n",
 858                         wlc->pub->unit, count, ampdu_len);
 859
 860                 /* inform rate_sel if it this is a rate probe pkt */
 861                 frameid = le16_to_cpu(txh->TxFrameID);
 862                 if (frameid & TXFID_RATE_PROBE_MASK)
 863                         wiphy_err(wiphy, "%s: XXX what to do with "
 864                                   "TXFID_RATE_PROBE_MASK!?\n", __func__);
 865
 866                 for (i = 0; i < count; i++)
 867                         brcms_c_txfifo(wlc, fifo, pkt[i], i == (count - 1),
 868                                    ampdu->txpkt_weight);
 869
 870         }
 871         /* endif (count) */
 872         return err;
 873 }
 874
 875 static void
 876 brcms_c_ampdu_rate_status(struct brcms_c_info *wlc,
 877                           struct ieee80211_tx_info *tx_info,
 878                           struct tx_status *txs, u8 mcs)
 879 {
 880         struct ieee80211_tx_rate *txrate = tx_info->status.rates;
 881         int i;
 882
 883         /* clear the rest of the rates */
 884         for (i = 2; i < IEEE80211_TX_MAX_RATES; i++) {
 885                 txrate[i].idx = -1;
 886                 txrate[i].count = 0;
 887         }
 888 }
 889
 890 static void
 891 brcms_c_ampdu_dotxstatus_complete(struct ampdu_info *ampdu, struct scb *scb,
 892                               struct sk_buff *p, struct tx_status *txs,
 893                               u32 s1, u32 s2)
 894 {
 895         struct scb_ampdu *scb_ampdu;
 896         struct brcms_c_info *wlc = ampdu->wlc;
 897         struct scb_ampdu_tid_ini *ini;
 898         u8 bitmap[8], queue, tid;
 899         struct d11txh *txh;
 900         u8 *plcp;
 901         struct ieee80211_hdr *h;
 902         u16 seq, start_seq = 0, bindex, index, mcl;
 903         u8 mcs = 0;
 904         bool ba_recd = false, ack_recd = false;
 905         u8 suc_mpdu = 0, tot_mpdu = 0;
 906         uint supr_status;
 907         bool update_rate = true, retry = true, tx_error = false;
 908         u16 mimoantsel = 0;
 909         u8 antselid = 0;
 910         u8 retry_limit, rr_retry_limit;
 911         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(p);
 912         struct wiphy *wiphy = wlc->wiphy;
 913
 914 #ifdef DEBUG
 915         u8 hole[AMPDU_MAX_MPDU];
 916         memset(hole, 0, sizeof(hole));
 917 #endif
 918
 919         scb_ampdu = &scb->scb_ampdu;
 920         tid = (u8) (p->priority);
 921
 922         ini = &scb_ampdu->ini[tid];
 923         retry_limit = ampdu->retry_limit_tid[tid];
 924         rr_retry_limit = ampdu->rr_retry_limit_tid[tid];
 925         memset(bitmap, 0, sizeof(bitmap));
 926         queue = txs->frameid & TXFID_QUEUE_MASK;
 927         supr_status = txs->status & TX_STATUS_SUPR_MASK;
 928
 929         if (txs->status & TX_STATUS_ACK_RCV) {
 930                 if (TX_STATUS_SUPR_UF == supr_status)
 931                         update_rate = false;
 932
 933                 WARN_ON(!(txs->status & TX_STATUS_INTERMEDIATE));
 934                 start_seq = txs->sequence >> SEQNUM_SHIFT;
 935                 bitmap[0] = (txs->status & TX_STATUS_BA_BMAP03_MASK) >>
 936                     TX_STATUS_BA_BMAP03_SHIFT;
 937
 938                 WARN_ON(s1 & TX_STATUS_INTERMEDIATE);
 939                 WARN_ON(!(s1 & TX_STATUS_AMPDU));
 940
 941                 bitmap[0] |=
 942                     (s1 & TX_STATUS_BA_BMAP47_MASK) <<
 943                     TX_STATUS_BA_BMAP47_SHIFT;
 944                 bitmap[1] = (s1 >> 8) & 0xff;
 945                 bitmap[2] = (s1 >> 16) & 0xff;
 946                 bitmap[3] = (s1 >> 24) & 0xff;
 947
 948                 bitmap[4] = s2 & 0xff;
 949                 bitmap[5] = (s2 >> 8) & 0xff;
 950                 bitmap[6] = (s2 >> 16) & 0xff;
 951                 bitmap[7] = (s2 >> 24) & 0xff;
 952
 953                 ba_recd = true;
 954         } else {
 955                 if (supr_status) {
 956                         update_rate = false;
 957                         if (supr_status == TX_STATUS_SUPR_BADCH) {
 958                                 wiphy_err(wiphy,
 959                                           "%s: Pkt tx suppressed, illegal channel possibly %d\n",
 960                                           __func__, CHSPEC_CHANNEL(
 961                                           wlc->default_bss->chanspec));
 962                         } else {
 963                                 if (supr_status != TX_STATUS_SUPR_FRAG)
 964                                         wiphy_err(wiphy, "%s: supr_status 0x%x\n",
 965                                                   __func__, supr_status);
 966                         }
 967                         /* no need to retry for badch; will fail again */
 968                         if (supr_status == TX_STATUS_SUPR_BADCH ||
 969                             supr_status == TX_STATUS_SUPR_EXPTIME) {
 970                                 retry = false;
 971                         } else if (supr_status == TX_STATUS_SUPR_EXPTIME) {
 972                                 /* TX underflow:
 973                                  *   try tuning pre-loading or ampdu size
 974                                  */
 975                         } else if (supr_status == TX_STATUS_SUPR_FRAG) {
 976                                 /*
 977                                  * if there were underflows, but pre-loading
 978                                  * is not active, notify rate adaptation.
 979                                  */
 980                                 if (brcms_c_ffpld_check_txfunfl(wlc,
 981                                         prio2fifo[tid]) > 0)
 982                                         tx_error = true;
 983                         }
 984                 } else if (txs->phyerr) {
 985                         update_rate = false;
 986                         wiphy_err(wiphy, "%s: ampdu tx phy error (0x%x)\n",
 987                                   __func__, txs->phyerr);
 988
 989                         if (brcm_msg_level & LOG_ERROR_VAL) {
 990                                 brcmu_prpkt("txpkt (AMPDU)", p);
 991                                 brcms_c_print_txdesc((struct d11txh *) p->data);
 992                         }
 993                         brcms_c_print_txstatus(txs);
 994                 }
 995         }
 996
 997         /* loop through all pkts and retry if not acked */
 998         while (p) {
 999                 tx_info = IEEE80211_SKB_CB(p);
1000                 txh = (struct d11txh *) p->data;
1001                 mcl = le16_to_cpu(txh->MacTxControlLow);
1002                 plcp = (u8 *) (txh + 1);
1003                 h = (struct ieee80211_hdr *)(plcp + D11_PHY_HDR_LEN);
1004                 seq = le16_to_cpu(h->seq_ctrl) >> SEQNUM_SHIFT;
1005
1006                 if (tot_mpdu == 0) {
1007                         mcs = plcp[0] & MIMO_PLCP_MCS_MASK;
1008                         mimoantsel = le16_to_cpu(txh->ABI_MimoAntSel);
1009                 }
1010
1011                 index = TX_SEQ_TO_INDEX(seq);
1012                 ack_recd = false;
1013                 if (ba_recd) {
1014                         bindex = MODSUB_POW2(seq, start_seq, SEQNUM_MAX);
1015                         BCMMSG(wiphy,
1016                                "tid %d seq %d, start_seq %d, bindex %d set %d, index %d\n",
1017                                tid, seq, start_seq, bindex,
1018                                isset(bitmap, bindex), index);
1019                         /* if acked then clear bit and free packet */
1020                         if ((bindex < AMPDU_TX_BA_MAX_WSIZE)
1021                             && isset(bitmap, bindex)) {
1022                                 ini->tx_in_transit--;
1023                                 ini->txretry[index] = 0;
1024
1025                                 /*
1026                                  * ampdu_ack_len:
1027                                  *   number of acked aggregated frames
1028                                  */
1029                                 /* ampdu_len: number of aggregated frames */
1030                                 brcms_c_ampdu_rate_status(wlc, tx_info, txs,
1031                                                           mcs);
1032                                 tx_info->flags |= IEEE80211_TX_STAT_ACK;
1033                                 tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
1034                                 tx_info->status.ampdu_ack_len =
1035                                         tx_info->status.ampdu_len = 1;
1036
1037                                 skb_pull(p, D11_PHY_HDR_LEN);
1038                                 skb_pull(p, D11_TXH_LEN);
1039
1040                                 ieee80211_tx_status_irqsafe(wlc->pub->ieee_hw,
1041                                                             p);
1042                                 ack_recd = true;
1043                                 suc_mpdu++;
1044                         }
1045                 }
1046                 /* either retransmit or send bar if ack not recd */
1047                 if (!ack_recd) {
1048                         if (retry && (ini->txretry[index] < (int)retry_limit)) {
1049                                 ini->txretry[index]++;
1050                                 ini->tx_in_transit--;
1051                                 /*
1052                                  * Use high prededence for retransmit to
1053                                  * give some punch
1054                                  */
1055                                 brcms_c_txq_enq(wlc, scb, p,
1056                                                 BRCMS_PRIO_TO_HI_PREC(tid));
1057                         } else {
1058                                 /* Retry timeout */
1059                                 ini->tx_in_transit--;
1060                                 ieee80211_tx_info_clear_status(tx_info);
1061                                 tx_info->status.ampdu_ack_len = 0;
1062                                 tx_info->status.ampdu_len = 1;
1063                                 tx_info->flags |=
1064                                     IEEE80211_TX_STAT_AMPDU_NO_BACK;
1065                                 skb_pull(p, D11_PHY_HDR_LEN);
1066                                 skb_pull(p, D11_TXH_LEN);
1067                                 BCMMSG(wiphy,
1068                                        "BA Timeout, seq %d, in_transit %d\n",
1069                                        seq, ini->tx_in_transit);
1070                                 ieee80211_tx_status_irqsafe(wlc->pub->ieee_hw,
1071                                                             p);
1072                         }
1073                 }
1074                 tot_mpdu++;
1075
1076                 /* break out if last packet of ampdu */
1077                 if (((mcl & TXC_AMPDU_MASK) >> TXC_AMPDU_SHIFT) ==
1078                     TXC_AMPDU_LAST)
1079                         break;
1080
1081                 p = dma_getnexttxp(wlc->hw->di[queue], DMA_RANGE_TRANSMITTED);
1082         }
1083         brcms_c_send_q(wlc);
1084
1085         /* update rate state */
1086         antselid = brcms_c_antsel_antsel2id(wlc->asi, mimoantsel);
1087
1088         brcms_c_txfifo_complete(wlc, queue, ampdu->txpkt_weight);
1089 }
1090
1091 void
1092 brcms_c_ampdu_dotxstatus(struct ampdu_info *ampdu, struct scb *scb,
1093                      struct sk_buff *p, struct tx_status *txs)
1094 {
1095         struct scb_ampdu *scb_ampdu;
1096         struct brcms_c_info *wlc = ampdu->wlc;
1097         struct scb_ampdu_tid_ini *ini;
1098         u32 s1 = 0, s2 = 0;
1099         struct ieee80211_tx_info *tx_info;
1100
1101         tx_info = IEEE80211_SKB_CB(p);
1102
1103         /* BMAC_NOTE: For the split driver, second level txstatus comes later
1104          * So if the ACK was received then wait for the second level else just
1105          * call the first one
1106          */
1107         if (txs->status & TX_STATUS_ACK_RCV) {
1108                 u8 status_delay = 0;
1109
1110                 /* wait till the next 8 bytes of txstatus is available */
1111                 s1 = bcma_read32(wlc->hw->d11core, D11REGOFFS(frmtxstatus));
1112                 while ((s1 & TXS_V) == 0) {
1113                         udelay(1);
1114                         status_delay++;
1115                         if (status_delay > 10)
1116                                 return; /* error condition */
1117                         s1 = bcma_read32(wlc->hw->d11core,
1118                                          D11REGOFFS(frmtxstatus));
1119                 }
1120
1121                 s2 = bcma_read32(wlc->hw->d11core, D11REGOFFS(frmtxstatus2));
1122         }
1123
1124         if (scb) {
1125                 scb_ampdu = &scb->scb_ampdu;
1126                 ini = &scb_ampdu->ini[p->priority];
1127                 brcms_c_ampdu_dotxstatus_complete(ampdu, scb, p, txs, s1, s2);
1128         } else {
1129                 /* loop through all pkts and free */
1130                 u8 queue = txs->frameid & TXFID_QUEUE_MASK;
1131                 struct d11txh *txh;
1132                 u16 mcl;
1133                 while (p) {
1134                         tx_info = IEEE80211_SKB_CB(p);
1135                         txh = (struct d11txh *) p->data;
1136                         mcl = le16_to_cpu(txh->MacTxControlLow);
1137                         brcmu_pkt_buf_free_skb(p);
1138                         /* break out if last packet of ampdu */
1139                         if (((mcl & TXC_AMPDU_MASK) >> TXC_AMPDU_SHIFT) ==
1140                             TXC_AMPDU_LAST)
1141                                 break;
1142                         p = dma_getnexttxp(wlc->hw->di[queue],
1143                                            DMA_RANGE_TRANSMITTED);
1144                 }
1145                 brcms_c_txfifo_complete(wlc, queue, ampdu->txpkt_weight);
1146         }
1147 }
1148
1149 void brcms_c_ampdu_macaddr_upd(struct brcms_c_info *wlc)
1150 {
1151         char template[T_RAM_ACCESS_SZ * 2];
1152
1153         /* driver needs to write the ta in the template; ta is at offset 16 */
1154         memset(template, 0, sizeof(template));
1155         memcpy(template, wlc->pub->cur_etheraddr, ETH_ALEN);
1156         brcms_b_write_template_ram(wlc->hw, (T_BA_TPL_BASE + 16),
1157                                   (T_RAM_ACCESS_SZ * 2),
1158                                   template);
1159 }
1160
1161 bool brcms_c_aggregatable(struct brcms_c_info *wlc, u8 tid)
1162 {
1163         return wlc->ampdu->ini_enable[tid];
1164 }
1165
1166 void brcms_c_ampdu_shm_upd(struct ampdu_info *ampdu)
1167 {
1168         struct brcms_c_info *wlc = ampdu->wlc;
1169
1170         /*
1171          * Extend ucode internal watchdog timer to
1172          * match larger received frames
1173          */
1174         if ((ampdu->rx_factor & IEEE80211_HT_AMPDU_PARM_FACTOR) ==
1175             IEEE80211_HT_MAX_AMPDU_64K) {
1176                 brcms_b_write_shm(wlc->hw, M_MIMO_MAXSYM, MIMO_MAXSYM_MAX);
1177                 brcms_b_write_shm(wlc->hw, M_WATCHDOG_8TU, WATCHDOG_8TU_MAX);
1178         } else {
1179                 brcms_b_write_shm(wlc->hw, M_MIMO_MAXSYM, MIMO_MAXSYM_DEF);
1180                 brcms_b_write_shm(wlc->hw, M_WATCHDOG_8TU, WATCHDOG_8TU_DEF);
1181         }
1182 }
1183
1184 /*
1185  * callback function that helps flushing ampdu packets from a priority queue
1186  */
1187 static bool cb_del_ampdu_pkt(struct sk_buff *mpdu, void *arg_a)
1188 {
1189         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(mpdu);
1190         struct cb_del_ampdu_pars *ampdu_pars =
1191                                  (struct cb_del_ampdu_pars *)arg_a;
1192         bool rc;
1193
1194         rc = tx_info->flags & IEEE80211_TX_CTL_AMPDU ? true : false;
1195         rc = rc && (tx_info->rate_driver_data[0] == NULL || ampdu_pars->sta == NULL ||
1196                     tx_info->rate_driver_data[0] == ampdu_pars->sta);
1197         rc = rc && ((u8)(mpdu->priority) == ampdu_pars->tid);
1198         return rc;
1199 }
1200
1201 /*
1202  * callback function that helps invalidating ampdu packets in a DMA queue
1203  */
1204 static void dma_cb_fn_ampdu(void *txi, void *arg_a)
1205 {
1206         struct ieee80211_sta *sta = arg_a;
1207         struct ieee80211_tx_info *tx_info = (struct ieee80211_tx_info *)txi;
1208
1209         if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) &&
1210             (tx_info->rate_driver_data[0] == sta || sta == NULL))
1211                 tx_info->rate_driver_data[0] = NULL;
1212 }
1213
1214 /*
1215  * When a remote party is no longer available for ampdu communication, any
1216  * pending tx ampdu packets in the driver have to be flushed.
1217  */
1218 void brcms_c_ampdu_flush(struct brcms_c_info *wlc,
1219                      struct ieee80211_sta *sta, u16 tid)
1220 {
1221         struct brcms_txq_info *qi = wlc->pkt_queue;
1222         struct pktq *pq = &qi->q;
1223         int prec;
1224         struct cb_del_ampdu_pars ampdu_pars;
1225
1226         ampdu_pars.sta = sta;
1227         ampdu_pars.tid = tid;
1228         for (prec = 0; prec < pq->num_prec; prec++)
1229                 brcmu_pktq_pflush(pq, prec, true, cb_del_ampdu_pkt,
1230                             (void *)&ampdu_pars);
1231         brcms_c_inval_dma_pkts(wlc->hw, sta, dma_cb_fn_ampdu);
1232 }