target_firmware/wlan/ar5416_hw.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 "ah.h"
  37 #include "ah_internal.h"
  38 #include "ar5416.h"
  39 #include "ar5416reg.h"
  40 #include "ar5416desc.h"
  41
  42 #define N(a) (sizeof(a)/sizeof(a[0]))
  43 #define AR_INTR_SPURIOUS 0xffffffff
  44 #define ar5416_desc ar5416_desc_20
  45 #define AR5416_ABORT_LOOPS 1000
  46 #define AR5416_ABORT_WAIT  5
  47 #define AR5416DESC         AR5416DESC_20
  48 #define AR5416DESC_CONST   AR5416DESC_CONST_20
  49
  50 /*****************/
  51 /* Attach/Detach */
  52 /*****************/
  53
  54 static const struct ath_hal_private ar5416hal_10 = {{
  55                 .ah_getRateTable        = ar5416GetRateTable,
  56                 .ah_detach              = ar5416Detach,
  57
  58                 /* Transmit functions */
  59                 .ah_updateTxTrigLevel   = ar5416UpdateTxTrigLevel,
  60                 .ah_setTxDP             = ar5416SetTxDP,
  61                 .ah_numTxPending        = ar5416NumTxPending,
  62                 .ah_startTxDma          = ar5416StartTxDma,
  63                 .ah_stopTxDma           = ar5416StopTxDma,
  64
  65                 .ah_abortTxDma          = ar5416AbortTxDma,
  66
  67                 /* Misc Functions */
  68                 .ah_getTsf64            = ar5416GetTsf64,
  69                 .ah_setRxFilter         = ar5416SetRxFilter,
  70
  71                 /* RX Functions */
  72                 .ah_setRxDP             = ar5416SetRxDP,
  73                 .ah_stopDmaReceive      = ar5416StopDmaReceive,
  74                 .ah_enableReceive       = ar5416EnableReceive,
  75                 .ah_stopPcuReceive      = ar5416StopPcuReceive,
  76
  77                 /* Interrupt Functions */
  78                 .ah_isInterruptPending   = ar5416IsInterruptPending,
  79                 .ah_getPendingInterrupts = ar5416GetPendingInterrupts,
  80                 .ah_setInterrupts        = ar5416SetInterrupts,
  81         },
  82 };
  83
  84 void ar5416Detach(struct ath_hal *ah)
  85 {
  86         HALASSERT(ah != AH_NULL);
  87         ath_hal_free(ah);
  88 }
  89
  90 struct ath_hal *
  91 ar5416Attach(a_uint32_t devid,HAL_SOFTC sc, adf_os_device_t dev,
  92              a_uint32_t flags, HAL_STATUS *status)
  93 {
  94         struct ath_hal_5416 *ahp;
  95         struct ath_hal *ah;
  96
  97         ahp = ath_hal_malloc(sizeof (struct ath_hal_5416));
  98         if (ahp == AH_NULL) {
  99                 *status = HAL_ENOMEM;
 100                 return AH_NULL;
 101         }
 102         ah = &ahp->ah_priv.h;
 103
 104         OS_MEMCPY(&ahp->ah_priv, &ar5416hal_10, sizeof(struct ath_hal_private));
 105
 106         ah->ah_dev = dev;
 107         ah->ah_sc = sc;
 108
 109         ah->ah_set11nTxDesc        = ar5416Set11nTxDesc_20;
 110         ah->ah_set11nRateScenario  = ar5416Set11nRateScenario_20;
 111         ah->ah_set11nAggrFirst     = ar5416Set11nAggrFirst_20;
 112         ah->ah_set11nAggrMiddle    = ar5416Set11nAggrMiddle_20;
 113         ah->ah_set11nAggrLast      = ar5416Set11nAggrLast_20;
 114         ah->ah_clr11nAggr          = ar5416Clr11nAggr_20;
 115         ah->ah_set11nBurstDuration = ar5416Set11nBurstDuration_20;
 116         ah->ah_setupRxDesc         = ar5416SetupRxDesc_20;
 117         ah->ah_procRxDescFast      = ar5416ProcRxDescFast_20;
 118         ah->ah_setupTxDesc         = ar5416SetupTxDesc_20;
 119         ah->ah_fillTxDesc          = ar5416FillTxDesc_20;
 120         ah->ah_fillKeyTxDesc       = ar5416FillKeyTxDesc_20;
 121         ah->ah_procTxDesc          = ar5416ProcTxDesc_20;
 122         ah->ah_set11nVirtualMoreFrag = ar5416Set11nVirtualMoreFrag_20;
 123
 124         return ah;
 125 }
 126
 127 /**********************/
 128 /* Interrupt Handling */
 129 /**********************/
 130
 131 HAL_BOOL ar5416IsInterruptPending(struct ath_hal *ah)
 132 {
 133         a_uint32_t host_isr = OS_REG_READ(ah, AR_INTR_ASYNC_CAUSE);
 134         /*
 135          * Some platforms trigger our ISR before applying power to
 136          * the card, so make sure.
 137          */
 138         return ((host_isr != AR_INTR_SPURIOUS) && (host_isr & AR_INTR_MAC_IRQ));
 139 }
 140
 141 HAL_BOOL ar5416GetPendingInterrupts(struct ath_hal *ah, HAL_INT *masked)
 142 {
 143         a_uint32_t isr;
 144 #ifndef AR9100
 145         HAL_BOOL fatal_int = AH_FALSE;
 146         a_uint32_t sync_cause;
 147
 148         if (OS_REG_READ(ah, AR_INTR_ASYNC_CAUSE) & AR_INTR_MAC_IRQ) {
 149                 if ((OS_REG_READ(ah, AR_RTC_STATUS) & AR_RTC_STATUS_M) != AR_RTC_STATUS_ON) {
 150                         *masked = 0;
 151                         return AH_FALSE;
 152                 }
 153         } else {
 154                 *masked = 0;
 155                 return AH_FALSE;
 156         }
 157 #endif
 158         isr = OS_REG_READ(ah, AR_ISR_RAC);
 159         if (isr == 0xffffffff) {
 160                 *masked = 0;
 161                 return AH_FALSE;
 162         }
 163
 164         *masked = isr & HAL_INT_COMMON;
 165
 166 #ifdef AR5416_INT_MITIGATION
 167         if (isr & (AR_ISR_RXMINTR | AR_ISR_RXINTM)) {
 168                 *masked |= HAL_INT_RX;
 169         }
 170         if (isr & (AR_ISR_TXMINTR | AR_ISR_TXINTM)) {
 171                 *masked |= HAL_INT_TX;
 172         }
 173 #endif
 174
 175         if (isr & AR_ISR_BCNMISC) {
 176                 a_uint32_t s2_s;
 177
 178                 s2_s = OS_REG_READ(ah, AR_ISR_S2_S);
 179
 180                 if (s2_s & AR_ISR_S2_GTT) {
 181                         *masked |= HAL_INT_GTT;
 182                 }
 183
 184                 if (s2_s & AR_ISR_S2_CST) {
 185                         *masked |= HAL_INT_CST;
 186                 }
 187         }
 188
 189         if (isr & (AR_ISR_RXOK | AR_ISR_RXERR))
 190                 *masked |= HAL_INT_RX;
 191         if (isr & (AR_ISR_TXOK | AR_ISR_TXDESC | AR_ISR_TXERR | AR_ISR_TXEOL)) {
 192                 struct ath_hal_5416 *ahp = AH5416(ah);
 193                 a_uint32_t           s0_s, s1_s;
 194
 195                 *masked |= HAL_INT_TX;
 196                 s0_s = OS_REG_READ(ah, AR_ISR_S0_S);
 197                 s1_s = OS_REG_READ(ah, AR_ISR_S1_S);
 198                 ahp->ah_intrTxqs |= MS(s0_s, AR_ISR_S0_QCU_TXOK);
 199                 ahp->ah_intrTxqs |= MS(s0_s, AR_ISR_S0_QCU_TXDESC);
 200                 ahp->ah_intrTxqs |= MS(s1_s, AR_ISR_S1_QCU_TXERR);
 201                 ahp->ah_intrTxqs |= MS(s1_s, AR_ISR_S1_QCU_TXEOL);
 202         }
 203
 204 #ifndef AR9100
 205         sync_cause = OS_REG_READ(ah, AR_INTR_SYNC_CAUSE);
 206         fatal_int = ((sync_cause != AR_INTR_SPURIOUS) &&
 207                      (sync_cause & (AR_INTR_SYNC_HOST1_FATAL | AR_INTR_SYNC_HOST1_PERR))) ?
 208                 AH_TRUE : AH_FALSE;
 209
 210         if (AH_TRUE == fatal_int) {
 211                 OS_REG_WRITE(ah, AR_INTR_SYNC_CAUSE_CLR, sync_cause);
 212                 (void) OS_REG_READ(ah, AR_INTR_SYNC_CAUSE_CLR);
 213         }
 214 #endif
 215         return AH_TRUE;
 216 }
 217
 218 HAL_INT
 219 ar5416SetInterrupts(struct ath_hal *ah, HAL_INT ints)
 220 {
 221         struct ath_hal_5416 *ahp = AH5416(ah);
 222         a_uint32_t omask = ahp->ah_maskReg;
 223         a_uint32_t mask;
 224
 225         if (omask & HAL_INT_GLOBAL) {
 226                 OS_REG_WRITE(ah, AR_IER, AR_IER_DISABLE);
 227                 (void) OS_REG_READ(ah, AR_IER);
 228         }
 229
 230         mask = ints & HAL_INT_COMMON;
 231         if (ints & HAL_INT_TX) {
 232 #ifdef AR5416_INT_MITIGATION
 233                 mask |= AR_IMR_TXMINTR | AR_IMR_TXINTM;
 234 #else
 235                 mask |= AR_IMR_TXOK;
 236                 mask |= AR_IMR_TXDESC;
 237 #endif
 238                 mask |= AR_IMR_TXERR;
 239                 mask |= AR_IMR_TXEOL;
 240         }
 241         if (ints & HAL_INT_RX) {
 242                 mask |= AR_IMR_RXERR;
 243 #ifdef AR5416_INT_MITIGATION
 244                 mask |=  AR_IMR_RXMINTR | AR_IMR_RXINTM;
 245 #else
 246                 mask |= AR_IMR_RXOK | AR_IMR_RXDESC;
 247 #endif
 248         }
 249
 250         if (ints & (HAL_INT_GTT | HAL_INT_CST)) {
 251                 mask |= AR_IMR_BCNMISC;
 252         }
 253
 254         OS_REG_WRITE(ah, AR_IMR, mask);
 255         (void) OS_REG_READ(ah, AR_IMR);
 256         ahp->ah_maskReg = ints;
 257
 258         /* Re-enable interrupts if they were enabled before. */
 259         if (ints & HAL_INT_GLOBAL) {
 260                 OS_REG_WRITE(ah, AR_IER, AR_IER_ENABLE);
 261                 /* See explanation above... */
 262                 (void) OS_REG_READ(ah, AR_IER);
 263         }
 264
 265         OS_REG_WRITE(ah, AR_INTR_ASYNC_ENABLE, AR_INTR_MAC_IRQ);
 266         OS_REG_WRITE(ah, AR_INTR_ASYNC_MASK, AR_INTR_MAC_IRQ);
 267         OS_REG_WRITE(ah, AR_INTR_SYNC_ENABLE, AR_INTR_SYNC_ALL);
 268
 269         return omask;
 270 }
 271
 272 /****************/
 273 /* TSF Handling */
 274 /****************/
 275
 276 u_int64_t ar5416GetTsf64(struct ath_hal *ah)
 277 {
 278         u_int64_t tsf;
 279
 280         tsf = OS_REG_READ(ah, AR_TSF_U32);
 281         tsf = (tsf << 32) | OS_REG_READ(ah, AR_TSF_L32);
 282
 283         return tsf;
 284 }
 285
 286 /******/
 287 /* RX */
 288 /******/
 289 void ar5416SetRxDP(struct ath_hal *ah, a_uint32_t rxdp)
 290 {
 291         OS_REG_WRITE(ah, AR_RXDP, rxdp);
 292         HALASSERT(OS_REG_READ(ah, AR_RXDP) == rxdp);
 293 }
 294
 295 void ar5416SetMulticastFilter(struct ath_hal *ah, a_uint32_t filter0, a_uint32_t filter1)
 296 {
 297         OS_REG_WRITE(ah, AR_MCAST_FIL0, filter0);
 298         OS_REG_WRITE(ah, AR_MCAST_FIL1, filter1);
 299 }
 300
 301 HAL_BOOL ar5416StopDmaReceive(struct ath_hal *ah)
 302 {
 303         OS_REG_WRITE(ah, AR_CR, AR_CR_RXD); /* Set receive disable bit */
 304         if (!ath_hal_wait(ah, AR_CR, AR_CR_RXE, 0)) {
 305                 return AH_FALSE;
 306         } else {
 307                 return AH_TRUE;
 308         }
 309 }
 310
 311 HAL_BOOL ar5416SetMulticastFilterIndex(struct ath_hal *ah, a_uint32_t ix)
 312 {
 313         a_uint32_t val;
 314
 315         if (ix >= 64)
 316                 return AH_FALSE;
 317         if (ix >= 32) {
 318                 val = OS_REG_READ(ah, AR_MCAST_FIL1);
 319                 OS_REG_WRITE(ah, AR_MCAST_FIL1, (val | (1<<(ix-32))));
 320         } else {
 321                 val = OS_REG_READ(ah, AR_MCAST_FIL0);
 322                 OS_REG_WRITE(ah, AR_MCAST_FIL0, (val | (1<<ix)));
 323         }
 324         return AH_TRUE;
 325 }
 326
 327 void ar5416SetRxFilter(struct ath_hal *ah, a_uint32_t bits)
 328 {
 329         a_uint32_t phybits;
 330
 331         OS_REG_WRITE(ah, AR_RX_FILTER, (bits & 0xff) | AR_RX_COMPR_BAR);
 332         phybits = 0;
 333         if (bits & HAL_RX_FILTER_PHYRADAR)
 334                 phybits |= AR_PHY_ERR_RADAR;
 335         if (bits & HAL_RX_FILTER_PHYERR)
 336                 phybits |= AR_PHY_ERR_OFDM_TIMING | AR_PHY_ERR_CCK_TIMING;
 337         OS_REG_WRITE(ah, AR_PHY_ERR, phybits);
 338         if (phybits) {
 339                 OS_REG_WRITE(ah, AR_RXCFG,OS_REG_READ(ah, AR_RXCFG) | AR_RXCFG_ZLFDMA);
 340         } else {
 341                 OS_REG_WRITE(ah, AR_RXCFG,OS_REG_READ(ah, AR_RXCFG) &~ AR_RXCFG_ZLFDMA);
 342         }
 343 }
 344
 345 void ar5416EnableReceive(struct ath_hal *ah)
 346 {
 347         OS_REG_WRITE(ah, AR_CR, AR_CR_RXE);
 348 }
 349
 350 void ar5416StopPcuReceive(struct ath_hal *ah)
 351 {
 352         OS_REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_RX_DIS);
 353 }
 354
 355 HAL_BOOL ar5416SetupRxDesc_20(struct ath_hal *ah, struct ath_rx_desc *ds,
 356                               a_uint32_t size, a_uint32_t flags)
 357 {
 358         struct ar5416_desc *ads = AR5416DESC(ds);
 359
 360         HALASSERT((size &~ AR_BufLen) == 0);
 361
 362         ads->ds_ctl1 = size & AR_BufLen;
 363         if (flags & HAL_RXDESC_INTREQ)
 364                 ads->ds_ctl1 |= AR_RxIntrReq;
 365
 366         /* this should be enough */
 367         ads->ds_rxstatus8 &= ~AR_RxDone;
 368
 369         return AH_TRUE;
 370 }
 371
 372 HAL_STATUS ar5416ProcRxDescFast_20(struct ath_hal *ah, struct ath_rx_desc *ds,
 373                                    a_uint32_t pa, struct ath_desc *nds,
 374                                    struct ath_rx_status *rx_stats)
 375 {
 376         struct ar5416_desc ads;
 377         struct ar5416_desc *adsp = AR5416DESC(ds);
 378         struct ar5416_desc *ands = AR5416DESC(nds);
 379
 380         if ((adsp->ds_rxstatus8 & AR_RxDone) == 0)
 381                 return HAL_EINPROGRESS;
 382         /*
 383          * Given the use of a self-linked tail be very sure that the hw is
 384          * done with this descriptor; the hw may have done this descriptor
 385          * once and picked it up again...make sure the hw has moved on.
 386          */
 387         if ((ands->ds_rxstatus8 & AR_RxDone) == 0
 388             && OS_REG_READ(ah, AR_RXDP) == pa)
 389                 return HAL_EINPROGRESS;
 390
 391         /*
 392          * Now we need to get the stats from the descriptor. Since desc are
 393          * uncached, lets make a copy of the stats first. Note that, since we
 394          * touch most of the rx stats, a memcpy would always be more efficient
 395          *
 396          * Next we fill in all values in a caller passed stack variable.
 397          * This reduces the number of uncached accesses.
 398          * Do this copy here, after the check so that when the checks fail, we
 399          * dont end up copying the entire stats uselessly.
 400          */
 401         ads.u.rx = adsp->u.rx;
 402
 403         rx_stats->rs_status = 0;
 404         rx_stats->rs_flags = 0;
 405
 406         rx_stats->rs_datalen = ads.ds_rxstatus1 & AR_DataLen;
 407         rx_stats->rs_tstamp =  ads.AR_RcvTimestamp;
 408
 409         /* XXX what about KeyCacheMiss? */
 410         rx_stats->rs_rssi_combined =
 411                 MS(ads.ds_rxstatus4, AR_RxRSSICombined);
 412         rx_stats->rs_rssi_ctl0 = MS(ads.ds_rxstatus0, AR_RxRSSIAnt00);
 413         rx_stats->rs_rssi_ctl1 = MS(ads.ds_rxstatus0, AR_RxRSSIAnt01);
 414         rx_stats->rs_rssi_ctl2 = MS(ads.ds_rxstatus0, AR_RxRSSIAnt02);
 415         rx_stats->rs_rssi_ext0 = MS(ads.ds_rxstatus4, AR_RxRSSIAnt10);
 416         rx_stats->rs_rssi_ext1 = MS(ads.ds_rxstatus4, AR_RxRSSIAnt11);
 417         rx_stats->rs_rssi_ext2 = MS(ads.ds_rxstatus4, AR_RxRSSIAnt12);
 418         if (ads.ds_rxstatus8 & AR_RxKeyIdxValid)
 419                 rx_stats->rs_keyix = MS(ads.ds_rxstatus8, AR_KeyIdx);
 420         else
 421                 rx_stats->rs_keyix = HAL_RXKEYIX_INVALID;
 422         /* NB: caller expected to do rate table mapping */
 423         rx_stats->rs_rate = RXSTATUS_RATE(ah, (&ads));
 424         rx_stats->rs_more = (ads.ds_rxstatus1 & AR_RxMore) ? 1 : 0;
 425
 426         rx_stats->rs_isaggr = (ads.ds_rxstatus8 & AR_RxAggr) ? 1 : 0;
 427         rx_stats->rs_moreaggr = (ads.ds_rxstatus8 & AR_RxMoreAggr) ? 1 : 0;
 428         rx_stats->rs_flags  |= (ads.ds_rxstatus3 & AR_GI) ? HAL_RX_GI : 0;
 429         rx_stats->rs_flags  |= (ads.ds_rxstatus3 & AR_2040) ? HAL_RX_2040 : 0;
 430
 431         if (ads.ds_rxstatus8 & AR_PreDelimCRCErr)
 432                 rx_stats->rs_flags |= HAL_RX_DELIM_CRC_PRE;
 433         if (ads.ds_rxstatus8 & AR_PostDelimCRCErr)
 434                 rx_stats->rs_flags |= HAL_RX_DELIM_CRC_POST;
 435         if (ads.ds_rxstatus8 & AR_DecryptBusyErr)
 436                 rx_stats->rs_flags |= HAL_RX_DECRYPT_BUSY;
 437
 438         if ((ads.ds_rxstatus8 & AR_RxFrameOK) == 0) {
 439                 /*
 440                  * These four bits should not be set together.  The
 441                  * 5416 spec states a Michael error can only occur if
 442                  * DecryptCRCErr not set (and TKIP is used).  Experience
 443                  * indicates however that you can also get Michael errors
 444                  * when a CRC error is detected, but these are specious.
 445                  * Consequently we filter them out here so we don't
 446                  * confuse and/or complicate drivers.
 447                  */
 448                 if (ads.ds_rxstatus8 & AR_CRCErr)
 449                         rx_stats->rs_status |= HAL_RXERR_CRC;
 450                 else if (ads.ds_rxstatus8 & AR_PHYErr) {
 451                         a_uint32_t phyerr;
 452
 453                         rx_stats->rs_status |= HAL_RXERR_PHY;
 454                         phyerr = MS(ads.ds_rxstatus8, AR_PHYErrCode);
 455                         rx_stats->rs_phyerr = phyerr;
 456                 } else if (ads.ds_rxstatus8 & AR_DecryptCRCErr)
 457                         rx_stats->rs_status |= HAL_RXERR_DECRYPT;
 458                 else if (ads.ds_rxstatus8 & AR_MichaelErr)
 459                         rx_stats->rs_status |= HAL_RXERR_MIC;
 460         }
 461         rx_stats->evm0=ads.AR_RxEVM0;
 462         rx_stats->evm1=ads.AR_RxEVM1;
 463         rx_stats->evm2=ads.AR_RxEVM2;
 464
 465         return HAL_OK;
 466 }
 467
 468 /******/
 469 /* TX */
 470 /******/
 471
 472 HAL_BOOL ar5416UpdateTxTrigLevel(struct ath_hal *ah, HAL_BOOL bIncTrigLevel)
 473 {
 474         struct ath_hal_5416 *ahp = AH5416(ah);
 475         a_uint32_t txcfg, curLevel, newLevel;
 476         HAL_INT omask;
 477
 478         /*
 479          * Disable interrupts while futzing with the fifo level.
 480          */
 481         omask = ar5416SetInterrupts(ah, ahp->ah_maskReg &~ HAL_INT_GLOBAL);
 482
 483         txcfg = OS_REG_READ(ah, AR_TXCFG);
 484         curLevel = MS(txcfg, AR_FTRIG);
 485         newLevel = curLevel;
 486
 487         if (bIncTrigLevel)  {
 488                 if (curLevel < MAX_TX_FIFO_THRESHOLD)
 489                         newLevel ++;
 490         } else if (curLevel > MIN_TX_FIFO_THRESHOLD)
 491                 newLevel--;
 492         if (newLevel != curLevel)
 493                 OS_REG_WRITE(ah, AR_TXCFG,
 494                              (txcfg &~ AR_FTRIG) | SM(newLevel, AR_FTRIG));
 495
 496         /* re-enable chip interrupts */
 497         ar5416SetInterrupts(ah, omask);
 498
 499         return (newLevel != curLevel);
 500 }
 501
 502 HAL_BOOL ar5416SetTxDP(struct ath_hal *ah, a_uint32_t q, a_uint32_t txdp)
 503 {
 504         HALASSERT(q < AH_PRIVATE(ah)->ah_caps.halTotalQueues);
 505         HALASSERT(AH5416(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE);
 506
 507         /*
 508          * Make sure that TXE is deasserted before setting the TXDP.  If TXE
 509          * is still asserted, setting TXDP will have no effect.
 510          */
 511         HALASSERT((OS_REG_READ(ah, AR_Q_TXE) & (1 << q)) == 0);
 512
 513         OS_REG_WRITE(ah, AR_QTXDP(q), txdp);
 514
 515         return AH_TRUE;
 516 }
 517
 518 HAL_BOOL ar5416StartTxDma(struct ath_hal *ah, a_uint32_t q)
 519 {
 520         HALASSERT(q < AH_PRIVATE(ah)->ah_caps.halTotalQueues);
 521         HALASSERT(AH5416(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE);
 522
 523         /* Check to be sure we're not enabling a q that has its TXD bit set. */
 524         HALASSERT((OS_REG_READ(ah, AR_Q_TXD) & (1 << q)) == 0);
 525
 526         OS_REG_WRITE(ah, AR_Q_TXE, 1 << q);
 527
 528         return AH_TRUE;
 529 }
 530
 531 a_uint32_t ar5416NumTxPending(struct ath_hal *ah, a_uint32_t q)
 532 {
 533         a_uint32_t npend;
 534
 535         HALASSERT(q < AH_PRIVATE(ah)->ah_caps.halTotalQueues);
 536         HALASSERT(AH5416(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE);
 537
 538         npend = OS_REG_READ(ah, AR_QSTS(q)) & AR_Q_STS_PEND_FR_CNT;
 539         if (npend == 0) {
 540                 /*
 541                  * Pending frame count (PFC) can momentarily go to zero
 542                  * while TXE remains asserted.  In other words a PFC of
 543                  * zero is not sufficient to say that the queue has stopped.
 544                  */
 545                 if (OS_REG_READ(ah, AR_Q_TXE) & (1 << q))
 546                         npend = 1;
 547         }
 548 #ifdef DEBUG
 549         if (npend && (AH5416(ah)->ah_txq[q].tqi_type == HAL_TX_QUEUE_CAB)) {
 550                 if (OS_REG_READ(ah, AR_Q_RDYTIMESHDN) & (1 << q)) {
 551                         isrPrintf("RTSD on CAB queue\n");
 552                         /* Clear the ReadyTime shutdown status bits */
 553                         OS_REG_WRITE(ah, AR_Q_RDYTIMESHDN, 1 << q);
 554                 }
 555         }
 556 #endif
 557         return npend;
 558 }
 559
 560 HAL_BOOL ar5416AbortTxDma(struct ath_hal *ah)
 561 {
 562         a_int32_t i, q;
 563
 564         /*
 565          * set txd on all queues
 566          */
 567         OS_REG_WRITE(ah, AR_Q_TXD, AR_Q_TXD_M);
 568
 569         /*
 570          * set tx abort bits
 571          */
 572         OS_REG_SET_BIT(ah, AR_PCU_MISC, (AR_PCU_FORCE_QUIET_COLL | AR_PCU_CLEAR_VMF));
 573         OS_REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
 574         OS_REG_SET_BIT(ah, AR_D_GBL_IFS_MISC, AR_D_GBL_IFS_MISC_IGNORE_BACKOFF);
 575
 576         /*
 577          * wait on all tx queues
 578          */
 579         for (q = 0; q < AR_NUM_QCU; q++) {
 580                 for (i = 0; i < AR5416_ABORT_LOOPS; i++) {
 581                         if (!ar5416NumTxPending(ah, q))
 582                                 break;
 583
 584                         OS_DELAY(AR5416_ABORT_WAIT);
 585                 }
 586                 if (i == AR5416_ABORT_LOOPS) {
 587                         return AH_FALSE;
 588                 }
 589         }
 590
 591         /*
 592          * clear tx abort bits
 593          */
 594         OS_REG_CLR_BIT(ah, AR_PCU_MISC, (AR_PCU_FORCE_QUIET_COLL | AR_PCU_CLEAR_VMF));
 595         OS_REG_CLR_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
 596         OS_REG_CLR_BIT(ah, AR_D_GBL_IFS_MISC, AR_D_GBL_IFS_MISC_IGNORE_BACKOFF);
 597
 598         /*
 599          * clear txd
 600          */
 601         OS_REG_WRITE(ah, AR_Q_TXD, 0);
 602
 603         return AH_TRUE;
 604 }
 605
 606 HAL_BOOL ar5416StopTxDma(struct ath_hal*ah, a_uint32_t q)
 607 {
 608         a_uint32_t i;
 609
 610         HALASSERT(q < AH_PRIVATE(ah)->ah_caps.halTotalQueues);
 611
 612         HALASSERT(AH5416(ah)->ah_txq[q].tqi_type != HAL_TX_QUEUE_INACTIVE);
 613
 614         OS_REG_WRITE(ah, AR_Q_TXD, 1 << q);
 615         for (i = 1000; i != 0; i--) {
 616                 if (ar5416NumTxPending(ah, q) == 0)
 617                         break;
 618                 OS_DELAY(100);        /* XXX get actual value */
 619         }
 620
 621         OS_REG_WRITE(ah, AR_Q_TXD, 0);
 622         return (i != 0);
 623 }
 624
 625 HAL_BOOL ar5416SetupTxDesc_20(struct ath_hal *ah, struct ath_tx_desc *ds,
 626                               a_uint32_t pktLen,
 627                               a_uint32_t hdrLen,
 628                               HAL_PKT_TYPE type,
 629                               a_uint32_t txPower,
 630                               a_uint32_t txRate0, a_uint32_t txTries0,
 631                               a_uint32_t keyIx,
 632                               a_uint32_t antMode,
 633                               a_uint32_t flags,
 634                               a_uint32_t rtsctsRate,
 635                               a_uint32_t rtsctsDuration,
 636                               a_uint32_t compicvLen,
 637                               a_uint32_t compivLen,
 638                               a_uint32_t comp)
 639 {
 640 #define RTSCTS  (HAL_TXDESC_RTSENA|HAL_TXDESC_CTSENA)
 641
 642         struct ar5416_desc *ads = AR5416DESC(ds);
 643
 644         (void) hdrLen;
 645
 646         ads->ds_txstatus9 &= ~AR_TxDone;
 647
 648         HALASSERT(txTries0 != 0);
 649         HALASSERT(isValidPktType(type));
 650         HALASSERT(isValidTxRate(txRate0));
 651         HALASSERT((flags & RTSCTS) != RTSCTS);
 652
 653         if (txPower > 63)
 654                 txPower=63;
 655
 656         ads->ds_ctl0 = (pktLen & AR_FrameLen)
 657                 | (txPower << AR_XmitPower_S)
 658                 | (flags & HAL_TXDESC_VEOL ? AR_VEOL : 0)
 659                 | (flags & HAL_TXDESC_CLRDMASK ? AR_ClrDestMask : 0)
 660                 | (flags & HAL_TXDESC_INTREQ ? AR_TxIntrReq : 0);
 661
 662         ads->ds_ctl1 = (type << AR_FrameType_S)
 663                 | (flags & HAL_TXDESC_NOACK ? AR_NoAck : 0);
 664         ads->ds_ctl2 = SM(txTries0, AR_XmitDataTries0);
 665         ads->ds_ctl3 = (txRate0 << AR_XmitRate0_S);
 666
 667         ads->ds_ctl7 = SM(AR5416_LEGACY_CHAINMASK, AR_ChainSel0)
 668                 | SM(AR5416_LEGACY_CHAINMASK, AR_ChainSel1)
 669                 | SM(AR5416_LEGACY_CHAINMASK, AR_ChainSel2)
 670                 | SM(AR5416_LEGACY_CHAINMASK, AR_ChainSel3);
 671
 672         if (keyIx != HAL_TXKEYIX_INVALID) {
 673                 /* XXX validate key index */
 674                 ads->ds_ctl1 |= SM(keyIx, AR_DestIdx);
 675                 ads->ds_ctl0 |= AR_DestIdxValid;
 676         }
 677
 678         if (flags & RTSCTS) {
 679                 if (!isValidTxRate(rtsctsRate)) {
 680                         return AH_FALSE;
 681                 }
 682                 /* XXX validate rtsctsDuration */
 683                 ads->ds_ctl0 |= (flags & HAL_TXDESC_CTSENA ? AR_CTSEnable : 0)
 684                         | (flags & HAL_TXDESC_RTSENA ? AR_RTSEnable : 0);
 685                 ads->ds_ctl2 |= SM(rtsctsDuration, AR_BurstDur);
 686                 ads->ds_ctl3 |= (rtsctsRate << AR_RTSCTSRate_S);
 687         }
 688         return AH_TRUE;
 689
 690 #undef RTSCTS
 691 }
 692
 693 HAL_BOOL ar5416FillTxDesc_20(struct ath_hal *ah, struct ath_tx_desc *ds,
 694                              a_uint32_t segLen, HAL_BOOL firstSeg, HAL_BOOL lastSeg,
 695                              const struct ath_tx_desc *ds0)
 696 {
 697         struct ar5416_desc *ads = AR5416DESC(ds);
 698
 699         HALASSERT((segLen &~ AR_BufLen) == 0);
 700
 701         if (firstSeg) {
 702                 /*
 703                  * First descriptor, don't clobber xmit control data
 704                  * setup by ar5416SetupTxDesc.
 705                  */
 706                 ads->ds_ctl1 |= segLen | (lastSeg ? 0 : AR_TxMore);
 707         } else if (lastSeg) {
 708                 /*
 709                  * Last descriptor in a multi-descriptor frame,
 710                  * copy the multi-rate transmit parameters from
 711                  * the first frame for processing on completion.
 712                  */
 713                 ads->ds_ctl0 = 0;
 714                 ads->ds_ctl1 = segLen;
 715                 ads->ds_ctl2 = AR5416DESC_CONST(ds0)->ds_ctl2;
 716                 ads->ds_ctl3 = AR5416DESC_CONST(ds0)->ds_ctl3;
 717         } else {
 718                 /*
 719                  * Intermediate descriptor in a multi-descriptor frame.
 720                  */
 721                 ads->ds_ctl0 = 0;
 722                 ads->ds_ctl1 = segLen | AR_TxMore;
 723                 ads->ds_ctl2 = 0;
 724                 ads->ds_ctl3 = 0;
 725         }
 726         ads->ds_txstatus0 = ads->ds_txstatus1 = 0;
 727
 728         return AH_TRUE;
 729 }
 730
 731 HAL_BOOL ar5416FillKeyTxDesc_20(struct ath_hal *ah, struct ath_tx_desc *ds,
 732                                 HAL_KEY_TYPE keyType)
 733 {
 734         struct ar5416_desc *ads = AR5416DESC(ds);
 735
 736         ads->ds_ctl6 = SM(keyType, AR_EncrType);
 737         return AH_TRUE;
 738 }
 739
 740 HAL_STATUS ar5416ProcTxDesc_20(struct ath_hal *ah, struct ath_tx_desc *gds)
 741 {
 742         struct ar5416_desc *ads = AR5416DESC(gds);
 743         struct ath_tx_desc *ds = (struct ath_tx_desc *)gds;
 744
 745         if ((ads->ds_txstatus9 & AR_TxDone) == 0)
 746                 return HAL_EINPROGRESS;
 747
 748         ads->ds_txstatus9 &= ~AR_TxDone;
 749
 750         /* Update software copies of the HW status */
 751         ds->ds_txstat.ts_seqnum = MS(ads->ds_txstatus9, AR_SeqNum);
 752         ds->ds_txstat.ts_tstamp = ads->AR_SendTimestamp;
 753         ds->ds_txstat.ts_status = 0;
 754         ds->ds_txstat.ts_flags  = 0;
 755
 756         if (ads->ds_txstatus1 & AR_ExcessiveRetries)
 757                 ds->ds_txstat.ts_status |= HAL_TXERR_XRETRY;
 758         if (ads->ds_txstatus1 & AR_Filtered)
 759                 ds->ds_txstat.ts_status |= HAL_TXERR_FILT;
 760         if (ads->ds_txstatus1 & AR_FIFOUnderrun)
 761                 ds->ds_txstat.ts_status |= HAL_TXERR_FIFO;
 762         if (ads->ds_txstatus9 & AR_TxOpExceeded)
 763                 ds->ds_txstat.ts_status |= HAL_TXERR_XTXOP;
 764         if (ads->ds_txstatus1 & AR_TxTimerExpired)
 765                 ds->ds_txstat.ts_status |= HAL_TXERR_TIMER_EXPIRED;
 766
 767         if (ads->ds_txstatus1 & AR_DescCfgErr)
 768                 ds->ds_txstat.ts_flags |= HAL_TX_DESC_CFG_ERR;
 769         if (ads->ds_txstatus1 & AR_TxDataUnderrun) {
 770                 ds->ds_txstat.ts_flags |= HAL_TX_DATA_UNDERRUN;
 771                 ar5416UpdateTxTrigLevel(ah, AH_TRUE);
 772         }
 773         if (ads->ds_txstatus1 & AR_TxDelimUnderrun) {
 774                 ds->ds_txstat.ts_flags |= HAL_TX_DELIM_UNDERRUN;
 775                 ar5416UpdateTxTrigLevel(ah, AH_TRUE);
 776         }
 777         if (ads->ds_txstatus0 & AR_TxBaStatus) {
 778                 ds->ds_txstat.ts_flags |= HAL_TX_BA;
 779                 ds->ds_txstat.ba_low = ads->AR_BaBitmapLow;
 780                 ds->ds_txstat.ba_high = ads->AR_BaBitmapHigh;
 781         }
 782
 783         /*
 784          * Extract the transmit rate used and mark the rate as
 785          * ``alternate'' if it wasn't the series 0 rate.
 786          */
 787         ds->ds_txstat.ts_rate = MS(ads->ds_txstatus9, AR_FinalTxIdx);
 788         ds->ds_txstat.ts_rssi_combined =
 789                 MS(ads->ds_txstatus5, AR_TxRSSICombined);
 790         ds->ds_txstat.ts_rssi_ctl0 = MS(ads->ds_txstatus0, AR_TxRSSIAnt00);
 791         ds->ds_txstat.ts_rssi_ctl1 = MS(ads->ds_txstatus0, AR_TxRSSIAnt01);
 792         ds->ds_txstat.ts_rssi_ctl2 = MS(ads->ds_txstatus0, AR_TxRSSIAnt02);
 793         ds->ds_txstat.ts_rssi_ext0 = MS(ads->ds_txstatus5, AR_TxRSSIAnt10);
 794         ds->ds_txstat.ts_rssi_ext1 = MS(ads->ds_txstatus5, AR_TxRSSIAnt11);
 795         ds->ds_txstat.ts_rssi_ext2 = MS(ads->ds_txstatus5, AR_TxRSSIAnt12);
 796         ds->ds_txstat.evm0 = ads->AR_TxEVM0;
 797         ds->ds_txstat.evm1 = ads->AR_TxEVM1;
 798         ds->ds_txstat.evm2 = ads->AR_TxEVM2;
 799         ds->ds_txstat.ts_shortretry = MS(ads->ds_txstatus1, AR_RTSFailCnt);
 800         ds->ds_txstat.ts_longretry = MS(ads->ds_txstatus1, AR_DataFailCnt);
 801         ds->ds_txstat.ts_virtcol = MS(ads->ds_txstatus1, AR_VirtRetryCnt);
 802         ds->ds_txstat.ts_antenna = 0;           /* ignored for owl */
 803
 804         return HAL_OK;
 805 }
 806
 807 void ar5416Set11nTxDesc_20(struct ath_hal *ah, struct ath_tx_desc *ds,
 808                            a_uint32_t pktLen, HAL_PKT_TYPE type, a_uint32_t txPower,
 809                            a_uint32_t keyIx, HAL_KEY_TYPE keyType,
 810                            a_uint32_t flags)
 811 {
 812         struct ar5416_desc *ads = AR5416DESC(ds);
 813
 814         HALASSERT(isValidPktType(type));
 815         HALASSERT(isValidKeyType(keyType));
 816
 817         if (txPower > 63)
 818                 txPower = 63;
 819
 820         ads->ds_ctl0 = (pktLen & AR_FrameLen)
 821                 | (flags & HAL_TXDESC_VMF ? AR_VirtMoreFrag : 0)
 822                 | SM(txPower, AR_XmitPower)
 823                 | (flags & HAL_TXDESC_RTSENA ? AR_RTSEnable : 0)
 824                 | (flags & HAL_TXDESC_VEOL ? AR_VEOL : 0)
 825                 | (flags & HAL_TXDESC_CLRDMASK ? AR_ClrDestMask : 0)
 826                 | (flags & HAL_TXDESC_INTREQ ? AR_TxIntrReq : 0)
 827                 | (keyIx != HAL_TXKEYIX_INVALID ? AR_DestIdxValid : 0)
 828                 | (flags & HAL_TXDESC_CTSENA ? AR_CTSEnable : 0);
 829
 830         ads->ds_ctl1 = (keyIx != HAL_TXKEYIX_INVALID ? SM(keyIx, AR_DestIdx) : 0)
 831                 | SM(type, AR_FrameType)
 832                 | (flags & HAL_TXDESC_NOACK ? AR_NoAck : 0)
 833                 | (flags & HAL_TXDESC_EXT_ONLY ? AR_ExtOnly : 0)
 834                 | (flags & HAL_TXDESC_EXT_AND_CTL ? AR_ExtAndCtl : 0);
 835
 836         ads->ds_ctl6 = SM(keyType, AR_EncrType);
 837 }
 838
 839 #ifdef MAGPIE_MERLIN
 840
 841 void ar5416Set11nRateScenario_20(struct ath_hal *ah, struct ath_tx_desc *ds,
 842                                  a_uint32_t durUpdateEn, a_uint32_t rtsctsRate,
 843                                  a_uint32_t rtsctsDuration,
 844                                  HAL_11N_RATE_SERIES series[], a_uint32_t nseries,
 845                                  a_uint32_t flags)
 846 {
 847         struct ar5416_desc *ads = AR5416DESC(ds);
 848         a_uint32_t ds_ctl0;
 849
 850         HALASSERT(nseries == 4);
 851         (void)nseries;
 852
 853         /*
 854          * Rate control settings override
 855          */
 856         ds_ctl0 = ads->ds_ctl0;
 857
 858         if (flags & (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA)) {
 859                 if (flags & HAL_TXDESC_RTSENA) {
 860                         ds_ctl0 &= ~AR_CTSEnable;
 861                         ds_ctl0 |= AR_RTSEnable;
 862                 } else {
 863                         ds_ctl0 &= ~AR_RTSEnable;
 864                         ds_ctl0 |= AR_CTSEnable;
 865                 }
 866         } else {
 867                 ds_ctl0 = (ds_ctl0 & ~(AR_RTSEnable | AR_CTSEnable));
 868         }
 869
 870         ads->ds_ctl0 = ds_ctl0;
 871
 872         ads->ds_ctl2 = set11nTries(series, 0)
 873                 |  set11nTries(series, 1)
 874                 |  set11nTries(series, 2)
 875                 |  set11nTries(series, 3)
 876                 |  (durUpdateEn ? AR_DurUpdateEn : 0);
 877
 878         ads->ds_ctl3 = set11nRate(series, 0)
 879                 |  set11nRate(series, 1)
 880                 |  set11nRate(series, 2)
 881                 |  set11nRate(series, 3);
 882
 883         ads->ds_ctl4 = set11nPktDurRTSCTS(series, 0)
 884                 |  set11nPktDurRTSCTS(series, 1);
 885
 886         ads->ds_ctl5 = set11nPktDurRTSCTS(series, 2)
 887                 |  set11nPktDurRTSCTS(series, 3);
 888
 889         ads->ds_ctl7 = set11nRateFlags(series, 0)
 890                 |  set11nRateFlags(series, 1)
 891                 |  set11nRateFlags(series, 2)
 892                 |  set11nRateFlags(series, 3)
 893                 | SM(rtsctsRate, AR_RTSCTSRate);
 894 }
 895
 896 #else
 897
 898 void ar5416Set11nRateScenario_20(struct ath_hal *ah, struct ath_tx_desc *ds,
 899                                  a_uint32_t durUpdateEn, a_uint32_t rtsctsRate,
 900                                  a_uint32_t rtsctsDuration,
 901                                  HAL_11N_RATE_SERIES series[], a_uint32_t nseries,
 902                                  a_uint32_t flags)
 903 {
 904         struct ar5416_desc *ads = AR5416DESC(ds);
 905         a_uint32_t ds_ctl0;
 906
 907         HALASSERT(nseries == 4);
 908         (void)nseries;
 909
 910         /*
 911          * Rate control settings override
 912          */
 913         if (flags & (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA)) {
 914                 ds_ctl0 = ads->ds_ctl0;
 915
 916                 if (flags & HAL_TXDESC_RTSENA) {
 917                         ds_ctl0 &= ~AR_CTSEnable;
 918                         ds_ctl0 |= AR_RTSEnable;
 919                 } else {
 920                         ds_ctl0 &= ~AR_RTSEnable;
 921                         ds_ctl0 |= AR_CTSEnable;
 922                 }
 923
 924                 ads->ds_ctl0 = ds_ctl0;
 925         }
 926
 927         ads->ds_ctl2 = set11nTries(series, 0)
 928                 |  set11nTries(series, 1)
 929                 |  set11nTries(series, 2)
 930                 |  set11nTries(series, 3)
 931                 |  (durUpdateEn ? AR_DurUpdateEn : 0);
 932
 933         ads->ds_ctl3 = set11nRate(series, 0)
 934                 |  set11nRate(series, 1)
 935                 |  set11nRate(series, 2)
 936                 |  set11nRate(series, 3);
 937
 938         ads->ds_ctl4 = set11nPktDurRTSCTS(series, 0)
 939                 |  set11nPktDurRTSCTS(series, 1);
 940
 941         ads->ds_ctl5 = set11nPktDurRTSCTS(series, 2)
 942                 |  set11nPktDurRTSCTS(series, 3);
 943
 944         ads->ds_ctl7 = set11nRateFlags(series, 0)
 945                 |  set11nRateFlags(series, 1)
 946                 |  set11nRateFlags(series, 2)
 947                 |  set11nRateFlags(series, 3)
 948                 | SM(rtsctsRate, AR_RTSCTSRate);
 949 }
 950
 951 #endif
 952
 953 void ar5416Set11nAggrFirst_20(struct ath_hal *ah, struct ath_tx_desc *ds, a_uint32_t aggrLen,
 954                               a_uint32_t numDelims)
 955 {
 956         struct ar5416_desc *ads = AR5416DESC(ds);
 957
 958         ads->ds_ctl1 |= (AR_IsAggr | AR_MoreAggr);
 959
 960         ads->ds_ctl6 &= ~(AR_AggrLen | AR_PadDelim);
 961         ads->ds_ctl6 |= SM(aggrLen, AR_AggrLen) |
 962                 SM(numDelims, AR_PadDelim);
 963 }
 964
 965 void ar5416Set11nAggrMiddle_20(struct ath_hal *ah, struct ath_tx_desc *ds, a_uint32_t numDelims)
 966 {
 967         struct ar5416_desc *ads = AR5416DESC(ds);
 968         a_uint32_t ctl6;
 969
 970         ads->ds_ctl1 |= (AR_IsAggr | AR_MoreAggr);
 971
 972         /*
 973          * We use a stack variable to manipulate ctl6 to reduce uncached
 974          * read modify, modfiy, write.
 975          */
 976         ctl6 = ads->ds_ctl6;
 977         ctl6 &= ~AR_PadDelim;
 978         ctl6 |= SM(numDelims, AR_PadDelim);
 979         ads->ds_ctl6 = ctl6;
 980 }
 981
 982 void ar5416Set11nAggrLast_20(struct ath_hal *ah, struct ath_tx_desc *ds)
 983 {
 984         struct ar5416_desc *ads = AR5416DESC(ds);
 985
 986         ads->ds_ctl1 |= AR_IsAggr;
 987         ads->ds_ctl1 &= ~AR_MoreAggr;
 988         ads->ds_ctl6 &= ~AR_PadDelim;
 989 }
 990
 991 void ar5416Clr11nAggr_20(struct ath_hal *ah, struct ath_tx_desc *ds)
 992 {
 993         struct ar5416_desc *ads = AR5416DESC(ds);
 994
 995         ads->ds_ctl1 &= (~AR_IsAggr & ~AR_MoreAggr);
 996 }
 997
 998 void ar5416Set11nBurstDuration_20(struct ath_hal *ah, struct ath_tx_desc *ds,
 999                                   a_uint32_t burstDuration)
1000 {
1001         struct ar5416_desc *ads = AR5416DESC(ds);
1002
1003         ads->ds_ctl2 &= ~AR_BurstDur;
1004         ads->ds_ctl2 |= SM(burstDuration, AR_BurstDur);
1005 }
1006
1007 void ar5416Set11nVirtualMoreFrag_20(struct ath_hal *ah, struct ath_tx_desc *ds,
1008                                     a_uint32_t vmf)
1009 {
1010         struct ar5416_desc *ads = AR5416DESC(ds);
1011
1012         if (vmf) {
1013                 ads->ds_ctl0 |= AR_VirtMoreFrag;
1014         } else {
1015                 ads->ds_ctl0 &= ~AR_VirtMoreFrag;
1016         }
1017 }