drivers/net/wireless/ath/ath9k/mac.c

   1 /*
   2  * Copyright (c) 2008-2009 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "hw.h"
  18
  19 static void ath9k_hw_set_txq_interrupts(struct ath_hw *ah,
  20                                         struct ath9k_tx_queue_info *qi)
  21 {
  22         ath_print(ath9k_hw_common(ah), ATH_DBG_INTERRUPT,
  23                   "tx ok 0x%x err 0x%x desc 0x%x eol 0x%x urn 0x%x\n",
  24                   ah->txok_interrupt_mask, ah->txerr_interrupt_mask,
  25                   ah->txdesc_interrupt_mask, ah->txeol_interrupt_mask,
  26                   ah->txurn_interrupt_mask);
  27
  28         REG_WRITE(ah, AR_IMR_S0,
  29                   SM(ah->txok_interrupt_mask, AR_IMR_S0_QCU_TXOK)
  30                   | SM(ah->txdesc_interrupt_mask, AR_IMR_S0_QCU_TXDESC));
  31         REG_WRITE(ah, AR_IMR_S1,
  32                   SM(ah->txerr_interrupt_mask, AR_IMR_S1_QCU_TXERR)
  33                   | SM(ah->txeol_interrupt_mask, AR_IMR_S1_QCU_TXEOL));
  34
  35         ah->imrs2_reg &= ~AR_IMR_S2_QCU_TXURN;
  36         ah->imrs2_reg |= (ah->txurn_interrupt_mask & AR_IMR_S2_QCU_TXURN);
  37         REG_WRITE(ah, AR_IMR_S2, ah->imrs2_reg);
  38 }
  39
  40 u32 ath9k_hw_gettxbuf(struct ath_hw *ah, u32 q)
  41 {
  42         return REG_READ(ah, AR_QTXDP(q));
  43 }
  44 EXPORT_SYMBOL(ath9k_hw_gettxbuf);
  45
  46 void ath9k_hw_puttxbuf(struct ath_hw *ah, u32 q, u32 txdp)
  47 {
  48         REG_WRITE(ah, AR_QTXDP(q), txdp);
  49 }
  50 EXPORT_SYMBOL(ath9k_hw_puttxbuf);
  51
  52 void ath9k_hw_txstart(struct ath_hw *ah, u32 q)
  53 {
  54         ath_print(ath9k_hw_common(ah), ATH_DBG_QUEUE,
  55                   "Enable TXE on queue: %u\n", q);
  56         REG_WRITE(ah, AR_Q_TXE, 1 << q);
  57 }
  58 EXPORT_SYMBOL(ath9k_hw_txstart);
  59
  60 void ath9k_hw_cleartxdesc(struct ath_hw *ah, void *ds)
  61 {
  62         struct ar5416_desc *ads = AR5416DESC(ds);
  63
  64         ads->ds_txstatus0 = ads->ds_txstatus1 = 0;
  65         ads->ds_txstatus2 = ads->ds_txstatus3 = 0;
  66         ads->ds_txstatus4 = ads->ds_txstatus5 = 0;
  67         ads->ds_txstatus6 = ads->ds_txstatus7 = 0;
  68         ads->ds_txstatus8 = ads->ds_txstatus9 = 0;
  69 }
  70 EXPORT_SYMBOL(ath9k_hw_cleartxdesc);
  71
  72 u32 ath9k_hw_numtxpending(struct ath_hw *ah, u32 q)
  73 {
  74         u32 npend;
  75
  76         npend = REG_READ(ah, AR_QSTS(q)) & AR_Q_STS_PEND_FR_CNT;
  77         if (npend == 0) {
  78
  79                 if (REG_READ(ah, AR_Q_TXE) & (1 << q))
  80                         npend = 1;
  81         }
  82
  83         return npend;
  84 }
  85 EXPORT_SYMBOL(ath9k_hw_numtxpending);
  86
  87 /**
  88  * ath9k_hw_updatetxtriglevel - adjusts the frame trigger level
  89  *
  90  * @ah: atheros hardware struct
  91  * @bIncTrigLevel: whether or not the frame trigger level should be updated
  92  *
  93  * The frame trigger level specifies the minimum number of bytes,
  94  * in units of 64 bytes, that must be DMA'ed into the PCU TX FIFO
  95  * before the PCU will initiate sending the frame on the air. This can
  96  * mean we initiate transmit before a full frame is on the PCU TX FIFO.
  97  * Resets to 0x1 (meaning 64 bytes or a full frame, whichever occurs
  98  * first)
  99  *
 100  * Caution must be taken to ensure to set the frame trigger level based
 101  * on the DMA request size. For example if the DMA request size is set to
 102  * 128 bytes the trigger level cannot exceed 6 * 64 = 384. This is because
 103  * there need to be enough space in the tx FIFO for the requested transfer
 104  * size. Hence the tx FIFO will stop with 512 - 128 = 384 bytes. If we set
 105  * the threshold to a value beyond 6, then the transmit will hang.
 106  *
 107  * Current dual   stream devices have a PCU TX FIFO size of 8 KB.
 108  * Current single stream devices have a PCU TX FIFO size of 4 KB, however,
 109  * there is a hardware issue which forces us to use 2 KB instead so the
 110  * frame trigger level must not exceed 2 KB for these chipsets.
 111  */
 112 bool ath9k_hw_updatetxtriglevel(struct ath_hw *ah, bool bIncTrigLevel)
 113 {
 114         u32 txcfg, curLevel, newLevel;
 115         enum ath9k_int omask;
 116
 117         if (ah->tx_trig_level >= ah->config.max_txtrig_level)
 118                 return false;
 119
 120         omask = ath9k_hw_set_interrupts(ah, ah->imask & ~ATH9K_INT_GLOBAL);
 121
 122         txcfg = REG_READ(ah, AR_TXCFG);
 123         curLevel = MS(txcfg, AR_FTRIG);
 124         newLevel = curLevel;
 125         if (bIncTrigLevel) {
 126                 if (curLevel < ah->config.max_txtrig_level)
 127                         newLevel++;
 128         } else if (curLevel > MIN_TX_FIFO_THRESHOLD)
 129                 newLevel--;
 130         if (newLevel != curLevel)
 131                 REG_WRITE(ah, AR_TXCFG,
 132                           (txcfg & ~AR_FTRIG) | SM(newLevel, AR_FTRIG));
 133
 134         ath9k_hw_set_interrupts(ah, omask);
 135
 136         ah->tx_trig_level = newLevel;
 137
 138         return newLevel != curLevel;
 139 }
 140 EXPORT_SYMBOL(ath9k_hw_updatetxtriglevel);
 141
 142 bool ath9k_hw_stoptxdma(struct ath_hw *ah, u32 q)
 143 {
 144 #define ATH9K_TX_STOP_DMA_TIMEOUT       4000    /* usec */
 145 #define ATH9K_TIME_QUANTUM              100     /* usec */
 146         struct ath_common *common = ath9k_hw_common(ah);
 147         struct ath9k_hw_capabilities *pCap = &ah->caps;
 148         struct ath9k_tx_queue_info *qi;
 149         u32 tsfLow, j, wait;
 150         u32 wait_time = ATH9K_TX_STOP_DMA_TIMEOUT / ATH9K_TIME_QUANTUM;
 151
 152         if (q >= pCap->total_queues) {
 153                 ath_print(common, ATH_DBG_QUEUE, "Stopping TX DMA, "
 154                           "invalid queue: %u\n", q);
 155                 return false;
 156         }
 157
 158         qi = &ah->txq[q];
 159         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
 160                 ath_print(common, ATH_DBG_QUEUE, "Stopping TX DMA, "
 161                           "inactive queue: %u\n", q);
 162                 return false;
 163         }
 164
 165         REG_WRITE(ah, AR_Q_TXD, 1 << q);
 166
 167         for (wait = wait_time; wait != 0; wait--) {
 168                 if (ath9k_hw_numtxpending(ah, q) == 0)
 169                         break;
 170                 udelay(ATH9K_TIME_QUANTUM);
 171         }
 172
 173         if (ath9k_hw_numtxpending(ah, q)) {
 174                 ath_print(common, ATH_DBG_QUEUE,
 175                           "%s: Num of pending TX Frames %d on Q %d\n",
 176                           __func__, ath9k_hw_numtxpending(ah, q), q);
 177
 178                 for (j = 0; j < 2; j++) {
 179                         tsfLow = REG_READ(ah, AR_TSF_L32);
 180                         REG_WRITE(ah, AR_QUIET2,
 181                                   SM(10, AR_QUIET2_QUIET_DUR));
 182                         REG_WRITE(ah, AR_QUIET_PERIOD, 100);
 183                         REG_WRITE(ah, AR_NEXT_QUIET_TIMER, tsfLow >> 10);
 184                         REG_SET_BIT(ah, AR_TIMER_MODE,
 185                                        AR_QUIET_TIMER_EN);
 186
 187                         if ((REG_READ(ah, AR_TSF_L32) >> 10) == (tsfLow >> 10))
 188                                 break;
 189
 190                         ath_print(common, ATH_DBG_QUEUE,
 191                                   "TSF has moved while trying to set "
 192                                   "quiet time TSF: 0x%08x\n", tsfLow);
 193                 }
 194
 195                 REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
 196
 197                 udelay(200);
 198                 REG_CLR_BIT(ah, AR_TIMER_MODE, AR_QUIET_TIMER_EN);
 199
 200                 wait = wait_time;
 201                 while (ath9k_hw_numtxpending(ah, q)) {
 202                         if ((--wait) == 0) {
 203                                 ath_print(common, ATH_DBG_FATAL,
 204                                           "Failed to stop TX DMA in 100 "
 205                                           "msec after killing last frame\n");
 206                                 break;
 207                         }
 208                         udelay(ATH9K_TIME_QUANTUM);
 209                 }
 210
 211                 REG_CLR_BIT(ah, AR_DIAG_SW, AR_DIAG_FORCE_CH_IDLE_HIGH);
 212         }
 213
 214         REG_WRITE(ah, AR_Q_TXD, 0);
 215         return wait != 0;
 216
 217 #undef ATH9K_TX_STOP_DMA_TIMEOUT
 218 #undef ATH9K_TIME_QUANTUM
 219 }
 220 EXPORT_SYMBOL(ath9k_hw_stoptxdma);
 221
 222 void ath9k_hw_gettxintrtxqs(struct ath_hw *ah, u32 *txqs)
 223 {
 224         *txqs &= ah->intr_txqs;
 225         ah->intr_txqs &= ~(*txqs);
 226 }
 227 EXPORT_SYMBOL(ath9k_hw_gettxintrtxqs);
 228
 229 bool ath9k_hw_set_txq_props(struct ath_hw *ah, int q,
 230                             const struct ath9k_tx_queue_info *qinfo)
 231 {
 232         u32 cw;
 233         struct ath_common *common = ath9k_hw_common(ah);
 234         struct ath9k_hw_capabilities *pCap = &ah->caps;
 235         struct ath9k_tx_queue_info *qi;
 236
 237         if (q >= pCap->total_queues) {
 238                 ath_print(common, ATH_DBG_QUEUE, "Set TXQ properties, "
 239                           "invalid queue: %u\n", q);
 240                 return false;
 241         }
 242
 243         qi = &ah->txq[q];
 244         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
 245                 ath_print(common, ATH_DBG_QUEUE, "Set TXQ properties, "
 246                           "inactive queue: %u\n", q);
 247                 return false;
 248         }
 249
 250         ath_print(common, ATH_DBG_QUEUE, "Set queue properties for: %u\n", q);
 251
 252         qi->tqi_ver = qinfo->tqi_ver;
 253         qi->tqi_subtype = qinfo->tqi_subtype;
 254         qi->tqi_qflags = qinfo->tqi_qflags;
 255         qi->tqi_priority = qinfo->tqi_priority;
 256         if (qinfo->tqi_aifs != ATH9K_TXQ_USEDEFAULT)
 257                 qi->tqi_aifs = min(qinfo->tqi_aifs, 255U);
 258         else
 259                 qi->tqi_aifs = INIT_AIFS;
 260         if (qinfo->tqi_cwmin != ATH9K_TXQ_USEDEFAULT) {
 261                 cw = min(qinfo->tqi_cwmin, 1024U);
 262                 qi->tqi_cwmin = 1;
 263                 while (qi->tqi_cwmin < cw)
 264                         qi->tqi_cwmin = (qi->tqi_cwmin << 1) | 1;
 265         } else
 266                 qi->tqi_cwmin = qinfo->tqi_cwmin;
 267         if (qinfo->tqi_cwmax != ATH9K_TXQ_USEDEFAULT) {
 268                 cw = min(qinfo->tqi_cwmax, 1024U);
 269                 qi->tqi_cwmax = 1;
 270                 while (qi->tqi_cwmax < cw)
 271                         qi->tqi_cwmax = (qi->tqi_cwmax << 1) | 1;
 272         } else
 273                 qi->tqi_cwmax = INIT_CWMAX;
 274
 275         if (qinfo->tqi_shretry != 0)
 276                 qi->tqi_shretry = min((u32) qinfo->tqi_shretry, 15U);
 277         else
 278                 qi->tqi_shretry = INIT_SH_RETRY;
 279         if (qinfo->tqi_lgretry != 0)
 280                 qi->tqi_lgretry = min((u32) qinfo->tqi_lgretry, 15U);
 281         else
 282                 qi->tqi_lgretry = INIT_LG_RETRY;
 283         qi->tqi_cbrPeriod = qinfo->tqi_cbrPeriod;
 284         qi->tqi_cbrOverflowLimit = qinfo->tqi_cbrOverflowLimit;
 285         qi->tqi_burstTime = qinfo->tqi_burstTime;
 286         qi->tqi_readyTime = qinfo->tqi_readyTime;
 287
 288         switch (qinfo->tqi_subtype) {
 289         case ATH9K_WME_UPSD:
 290                 if (qi->tqi_type == ATH9K_TX_QUEUE_DATA)
 291                         qi->tqi_intFlags = ATH9K_TXQ_USE_LOCKOUT_BKOFF_DIS;
 292                 break;
 293         default:
 294                 break;
 295         }
 296
 297         return true;
 298 }
 299 EXPORT_SYMBOL(ath9k_hw_set_txq_props);
 300
 301 bool ath9k_hw_get_txq_props(struct ath_hw *ah, int q,
 302                             struct ath9k_tx_queue_info *qinfo)
 303 {
 304         struct ath_common *common = ath9k_hw_common(ah);
 305         struct ath9k_hw_capabilities *pCap = &ah->caps;
 306         struct ath9k_tx_queue_info *qi;
 307
 308         if (q >= pCap->total_queues) {
 309                 ath_print(common, ATH_DBG_QUEUE, "Get TXQ properties, "
 310                           "invalid queue: %u\n", q);
 311                 return false;
 312         }
 313
 314         qi = &ah->txq[q];
 315         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
 316                 ath_print(common, ATH_DBG_QUEUE, "Get TXQ properties, "
 317                           "inactive queue: %u\n", q);
 318                 return false;
 319         }
 320
 321         qinfo->tqi_qflags = qi->tqi_qflags;
 322         qinfo->tqi_ver = qi->tqi_ver;
 323         qinfo->tqi_subtype = qi->tqi_subtype;
 324         qinfo->tqi_qflags = qi->tqi_qflags;
 325         qinfo->tqi_priority = qi->tqi_priority;
 326         qinfo->tqi_aifs = qi->tqi_aifs;
 327         qinfo->tqi_cwmin = qi->tqi_cwmin;
 328         qinfo->tqi_cwmax = qi->tqi_cwmax;
 329         qinfo->tqi_shretry = qi->tqi_shretry;
 330         qinfo->tqi_lgretry = qi->tqi_lgretry;
 331         qinfo->tqi_cbrPeriod = qi->tqi_cbrPeriod;
 332         qinfo->tqi_cbrOverflowLimit = qi->tqi_cbrOverflowLimit;
 333         qinfo->tqi_burstTime = qi->tqi_burstTime;
 334         qinfo->tqi_readyTime = qi->tqi_readyTime;
 335
 336         return true;
 337 }
 338 EXPORT_SYMBOL(ath9k_hw_get_txq_props);
 339
 340 int ath9k_hw_setuptxqueue(struct ath_hw *ah, enum ath9k_tx_queue type,
 341                           const struct ath9k_tx_queue_info *qinfo)
 342 {
 343         struct ath_common *common = ath9k_hw_common(ah);
 344         struct ath9k_tx_queue_info *qi;
 345         struct ath9k_hw_capabilities *pCap = &ah->caps;
 346         int q;
 347
 348         switch (type) {
 349         case ATH9K_TX_QUEUE_BEACON:
 350                 q = pCap->total_queues - 1;
 351                 break;
 352         case ATH9K_TX_QUEUE_CAB:
 353                 q = pCap->total_queues - 2;
 354                 break;
 355         case ATH9K_TX_QUEUE_PSPOLL:
 356                 q = 1;
 357                 break;
 358         case ATH9K_TX_QUEUE_UAPSD:
 359                 q = pCap->total_queues - 3;
 360                 break;
 361         case ATH9K_TX_QUEUE_DATA:
 362                 for (q = 0; q < pCap->total_queues; q++)
 363                         if (ah->txq[q].tqi_type ==
 364                             ATH9K_TX_QUEUE_INACTIVE)
 365                                 break;
 366                 if (q == pCap->total_queues) {
 367                         ath_print(common, ATH_DBG_FATAL,
 368                                   "No available TX queue\n");
 369                         return -1;
 370                 }
 371                 break;
 372         default:
 373                 ath_print(common, ATH_DBG_FATAL,
 374                           "Invalid TX queue type: %u\n", type);
 375                 return -1;
 376         }
 377
 378         ath_print(common, ATH_DBG_QUEUE, "Setup TX queue: %u\n", q);
 379
 380         qi = &ah->txq[q];
 381         if (qi->tqi_type != ATH9K_TX_QUEUE_INACTIVE) {
 382                 ath_print(common, ATH_DBG_FATAL,
 383                           "TX queue: %u already active\n", q);
 384                 return -1;
 385         }
 386         memset(qi, 0, sizeof(struct ath9k_tx_queue_info));
 387         qi->tqi_type = type;
 388         if (qinfo == NULL) {
 389                 qi->tqi_qflags =
 390                         TXQ_FLAG_TXOKINT_ENABLE
 391                         | TXQ_FLAG_TXERRINT_ENABLE
 392                         | TXQ_FLAG_TXDESCINT_ENABLE | TXQ_FLAG_TXURNINT_ENABLE;
 393                 qi->tqi_aifs = INIT_AIFS;
 394                 qi->tqi_cwmin = ATH9K_TXQ_USEDEFAULT;
 395                 qi->tqi_cwmax = INIT_CWMAX;
 396                 qi->tqi_shretry = INIT_SH_RETRY;
 397                 qi->tqi_lgretry = INIT_LG_RETRY;
 398                 qi->tqi_physCompBuf = 0;
 399         } else {
 400                 qi->tqi_physCompBuf = qinfo->tqi_physCompBuf;
 401                 (void) ath9k_hw_set_txq_props(ah, q, qinfo);
 402         }
 403
 404         return q;
 405 }
 406 EXPORT_SYMBOL(ath9k_hw_setuptxqueue);
 407
 408 bool ath9k_hw_releasetxqueue(struct ath_hw *ah, u32 q)
 409 {
 410         struct ath9k_hw_capabilities *pCap = &ah->caps;
 411         struct ath_common *common = ath9k_hw_common(ah);
 412         struct ath9k_tx_queue_info *qi;
 413
 414         if (q >= pCap->total_queues) {
 415                 ath_print(common, ATH_DBG_QUEUE, "Release TXQ, "
 416                           "invalid queue: %u\n", q);
 417                 return false;
 418         }
 419         qi = &ah->txq[q];
 420         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
 421                 ath_print(common, ATH_DBG_QUEUE, "Release TXQ, "
 422                           "inactive queue: %u\n", q);
 423                 return false;
 424         }
 425
 426         ath_print(common, ATH_DBG_QUEUE, "Release TX queue: %u\n", q);
 427
 428         qi->tqi_type = ATH9K_TX_QUEUE_INACTIVE;
 429         ah->txok_interrupt_mask &= ~(1 << q);
 430         ah->txerr_interrupt_mask &= ~(1 << q);
 431         ah->txdesc_interrupt_mask &= ~(1 << q);
 432         ah->txeol_interrupt_mask &= ~(1 << q);
 433         ah->txurn_interrupt_mask &= ~(1 << q);
 434         ath9k_hw_set_txq_interrupts(ah, qi);
 435
 436         return true;
 437 }
 438 EXPORT_SYMBOL(ath9k_hw_releasetxqueue);
 439
 440 bool ath9k_hw_resettxqueue(struct ath_hw *ah, u32 q)
 441 {
 442         struct ath9k_hw_capabilities *pCap = &ah->caps;
 443         struct ath_common *common = ath9k_hw_common(ah);
 444         struct ath9k_channel *chan = ah->curchan;
 445         struct ath9k_tx_queue_info *qi;
 446         u32 cwMin, chanCwMin, value;
 447
 448         if (q >= pCap->total_queues) {
 449                 ath_print(common, ATH_DBG_QUEUE, "Reset TXQ, "
 450                           "invalid queue: %u\n", q);
 451                 return false;
 452         }
 453
 454         qi = &ah->txq[q];
 455         if (qi->tqi_type == ATH9K_TX_QUEUE_INACTIVE) {
 456                 ath_print(common, ATH_DBG_QUEUE, "Reset TXQ, "
 457                           "inactive queue: %u\n", q);
 458                 return true;
 459         }
 460
 461         ath_print(common, ATH_DBG_QUEUE, "Reset TX queue: %u\n", q);
 462
 463         if (qi->tqi_cwmin == ATH9K_TXQ_USEDEFAULT) {
 464                 if (chan && IS_CHAN_B(chan))
 465                         chanCwMin = INIT_CWMIN_11B;
 466                 else
 467                         chanCwMin = INIT_CWMIN;
 468
 469                 for (cwMin = 1; cwMin < chanCwMin; cwMin = (cwMin << 1) | 1);
 470         } else
 471                 cwMin = qi->tqi_cwmin;
 472
 473         REG_WRITE(ah, AR_DLCL_IFS(q),
 474                   SM(cwMin, AR_D_LCL_IFS_CWMIN) |
 475                   SM(qi->tqi_cwmax, AR_D_LCL_IFS_CWMAX) |
 476                   SM(qi->tqi_aifs, AR_D_LCL_IFS_AIFS));
 477
 478         REG_WRITE(ah, AR_DRETRY_LIMIT(q),
 479                   SM(INIT_SSH_RETRY, AR_D_RETRY_LIMIT_STA_SH) |
 480                   SM(INIT_SLG_RETRY, AR_D_RETRY_LIMIT_STA_LG) |
 481                   SM(qi->tqi_shretry, AR_D_RETRY_LIMIT_FR_SH));
 482
 483         REG_WRITE(ah, AR_QMISC(q), AR_Q_MISC_DCU_EARLY_TERM_REQ);
 484         REG_WRITE(ah, AR_DMISC(q),
 485                   AR_D_MISC_CW_BKOFF_EN | AR_D_MISC_FRAG_WAIT_EN | 0x2);
 486
 487         if (qi->tqi_cbrPeriod) {
 488                 REG_WRITE(ah, AR_QCBRCFG(q),
 489                           SM(qi->tqi_cbrPeriod, AR_Q_CBRCFG_INTERVAL) |
 490                           SM(qi->tqi_cbrOverflowLimit, AR_Q_CBRCFG_OVF_THRESH));
 491                 REG_WRITE(ah, AR_QMISC(q),
 492                           REG_READ(ah, AR_QMISC(q)) | AR_Q_MISC_FSP_CBR |
 493                           (qi->tqi_cbrOverflowLimit ?
 494                            AR_Q_MISC_CBR_EXP_CNTR_LIMIT_EN : 0));
 495         }
 496         if (qi->tqi_readyTime && (qi->tqi_type != ATH9K_TX_QUEUE_CAB)) {
 497                 REG_WRITE(ah, AR_QRDYTIMECFG(q),
 498                           SM(qi->tqi_readyTime, AR_Q_RDYTIMECFG_DURATION) |
 499                           AR_Q_RDYTIMECFG_EN);
 500         }
 501
 502         REG_WRITE(ah, AR_DCHNTIME(q),
 503                   SM(qi->tqi_burstTime, AR_D_CHNTIME_DUR) |
 504                   (qi->tqi_burstTime ? AR_D_CHNTIME_EN : 0));
 505
 506         if (qi->tqi_burstTime
 507             && (qi->tqi_qflags & TXQ_FLAG_RDYTIME_EXP_POLICY_ENABLE)) {
 508                 REG_WRITE(ah, AR_QMISC(q),
 509                           REG_READ(ah, AR_QMISC(q)) |
 510                           AR_Q_MISC_RDYTIME_EXP_POLICY);
 511
 512         }
 513
 514         if (qi->tqi_qflags & TXQ_FLAG_BACKOFF_DISABLE) {
 515                 REG_WRITE(ah, AR_DMISC(q),
 516                           REG_READ(ah, AR_DMISC(q)) |
 517                           AR_D_MISC_POST_FR_BKOFF_DIS);
 518         }
 519         if (qi->tqi_qflags & TXQ_FLAG_FRAG_BURST_BACKOFF_ENABLE) {
 520                 REG_WRITE(ah, AR_DMISC(q),
 521                           REG_READ(ah, AR_DMISC(q)) |
 522                           AR_D_MISC_FRAG_BKOFF_EN);
 523         }
 524         switch (qi->tqi_type) {
 525         case ATH9K_TX_QUEUE_BEACON:
 526                 REG_WRITE(ah, AR_QMISC(q), REG_READ(ah, AR_QMISC(q))
 527                           | AR_Q_MISC_FSP_DBA_GATED
 528                           | AR_Q_MISC_BEACON_USE
 529                           | AR_Q_MISC_CBR_INCR_DIS1);
 530
 531                 REG_WRITE(ah, AR_DMISC(q), REG_READ(ah, AR_DMISC(q))
 532                           | (AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL <<
 533                              AR_D_MISC_ARB_LOCKOUT_CNTRL_S)
 534                           | AR_D_MISC_BEACON_USE
 535                           | AR_D_MISC_POST_FR_BKOFF_DIS);
 536                 /* cwmin and cwmax should be 0 for beacon queue */
 537                 if (AR_SREV_9300_20_OR_LATER(ah)) {
 538                         REG_WRITE(ah, AR_DLCL_IFS(q), SM(0, AR_D_LCL_IFS_CWMIN)
 539                                   | SM(0, AR_D_LCL_IFS_CWMAX)
 540                                   | SM(qi->tqi_aifs, AR_D_LCL_IFS_AIFS));
 541                 }
 542                 break;
 543         case ATH9K_TX_QUEUE_CAB:
 544                 REG_WRITE(ah, AR_QMISC(q), REG_READ(ah, AR_QMISC(q))
 545                           | AR_Q_MISC_FSP_DBA_GATED
 546                           | AR_Q_MISC_CBR_INCR_DIS1
 547                           | AR_Q_MISC_CBR_INCR_DIS0);
 548                 value = (qi->tqi_readyTime -
 549                          (ah->config.sw_beacon_response_time -
 550                           ah->config.dma_beacon_response_time) -
 551                          ah->config.additional_swba_backoff) * 1024;
 552                 REG_WRITE(ah, AR_QRDYTIMECFG(q),
 553                           value | AR_Q_RDYTIMECFG_EN);
 554                 REG_WRITE(ah, AR_DMISC(q), REG_READ(ah, AR_DMISC(q))
 555                           | (AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL <<
 556                              AR_D_MISC_ARB_LOCKOUT_CNTRL_S));
 557                 break;
 558         case ATH9K_TX_QUEUE_PSPOLL:
 559                 REG_WRITE(ah, AR_QMISC(q),
 560                           REG_READ(ah, AR_QMISC(q)) | AR_Q_MISC_CBR_INCR_DIS1);
 561                 break;
 562         case ATH9K_TX_QUEUE_UAPSD:
 563                 REG_WRITE(ah, AR_DMISC(q), REG_READ(ah, AR_DMISC(q)) |
 564                           AR_D_MISC_POST_FR_BKOFF_DIS);
 565                 break;
 566         default:
 567                 break;
 568         }
 569
 570         if (qi->tqi_intFlags & ATH9K_TXQ_USE_LOCKOUT_BKOFF_DIS) {
 571                 REG_WRITE(ah, AR_DMISC(q),
 572                           REG_READ(ah, AR_DMISC(q)) |
 573                           SM(AR_D_MISC_ARB_LOCKOUT_CNTRL_GLOBAL,
 574                              AR_D_MISC_ARB_LOCKOUT_CNTRL) |
 575                           AR_D_MISC_POST_FR_BKOFF_DIS);
 576         }
 577
 578         if (AR_SREV_9300_20_OR_LATER(ah))
 579                 REG_WRITE(ah, AR_Q_DESC_CRCCHK, AR_Q_DESC_CRCCHK_EN);
 580
 581         if (qi->tqi_qflags & TXQ_FLAG_TXOKINT_ENABLE)
 582                 ah->txok_interrupt_mask |= 1 << q;
 583         else
 584                 ah->txok_interrupt_mask &= ~(1 << q);
 585         if (qi->tqi_qflags & TXQ_FLAG_TXERRINT_ENABLE)
 586                 ah->txerr_interrupt_mask |= 1 << q;
 587         else
 588                 ah->txerr_interrupt_mask &= ~(1 << q);
 589         if (qi->tqi_qflags & TXQ_FLAG_TXDESCINT_ENABLE)
 590                 ah->txdesc_interrupt_mask |= 1 << q;
 591         else
 592                 ah->txdesc_interrupt_mask &= ~(1 << q);
 593         if (qi->tqi_qflags & TXQ_FLAG_TXEOLINT_ENABLE)
 594                 ah->txeol_interrupt_mask |= 1 << q;
 595         else
 596                 ah->txeol_interrupt_mask &= ~(1 << q);
 597         if (qi->tqi_qflags & TXQ_FLAG_TXURNINT_ENABLE)
 598                 ah->txurn_interrupt_mask |= 1 << q;
 599         else
 600                 ah->txurn_interrupt_mask &= ~(1 << q);
 601         ath9k_hw_set_txq_interrupts(ah, qi);
 602
 603         return true;
 604 }
 605 EXPORT_SYMBOL(ath9k_hw_resettxqueue);
 606
 607 int ath9k_hw_rxprocdesc(struct ath_hw *ah, struct ath_desc *ds,
 608                         struct ath_rx_status *rs, u64 tsf)
 609 {
 610         struct ar5416_desc ads;
 611         struct ar5416_desc *adsp = AR5416DESC(ds);
 612         u32 phyerr;
 613
 614         if ((adsp->ds_rxstatus8 & AR_RxDone) == 0)
 615                 return -EINPROGRESS;
 616
 617         ads.u.rx = adsp->u.rx;
 618
 619         rs->rs_status = 0;
 620         rs->rs_flags = 0;
 621
 622         rs->rs_datalen = ads.ds_rxstatus1 & AR_DataLen;
 623         rs->rs_tstamp = ads.AR_RcvTimestamp;
 624
 625         if (ads.ds_rxstatus8 & AR_PostDelimCRCErr) {
 626                 rs->rs_rssi = ATH9K_RSSI_BAD;
 627                 rs->rs_rssi_ctl0 = ATH9K_RSSI_BAD;
 628                 rs->rs_rssi_ctl1 = ATH9K_RSSI_BAD;
 629                 rs->rs_rssi_ctl2 = ATH9K_RSSI_BAD;
 630                 rs->rs_rssi_ext0 = ATH9K_RSSI_BAD;
 631                 rs->rs_rssi_ext1 = ATH9K_RSSI_BAD;
 632                 rs->rs_rssi_ext2 = ATH9K_RSSI_BAD;
 633         } else {
 634                 rs->rs_rssi = MS(ads.ds_rxstatus4, AR_RxRSSICombined);
 635                 rs->rs_rssi_ctl0 = MS(ads.ds_rxstatus0,
 636                                                 AR_RxRSSIAnt00);
 637                 rs->rs_rssi_ctl1 = MS(ads.ds_rxstatus0,
 638                                                 AR_RxRSSIAnt01);
 639                 rs->rs_rssi_ctl2 = MS(ads.ds_rxstatus0,
 640                                                 AR_RxRSSIAnt02);
 641                 rs->rs_rssi_ext0 = MS(ads.ds_rxstatus4,
 642                                                 AR_RxRSSIAnt10);
 643                 rs->rs_rssi_ext1 = MS(ads.ds_rxstatus4,
 644                                                 AR_RxRSSIAnt11);
 645                 rs->rs_rssi_ext2 = MS(ads.ds_rxstatus4,
 646                                                 AR_RxRSSIAnt12);
 647         }
 648         if (ads.ds_rxstatus8 & AR_RxKeyIdxValid)
 649                 rs->rs_keyix = MS(ads.ds_rxstatus8, AR_KeyIdx);
 650         else
 651                 rs->rs_keyix = ATH9K_RXKEYIX_INVALID;
 652
 653         rs->rs_rate = RXSTATUS_RATE(ah, (&ads));
 654         rs->rs_more = (ads.ds_rxstatus1 & AR_RxMore) ? 1 : 0;
 655
 656         rs->rs_isaggr = (ads.ds_rxstatus8 & AR_RxAggr) ? 1 : 0;
 657         rs->rs_moreaggr =
 658                 (ads.ds_rxstatus8 & AR_RxMoreAggr) ? 1 : 0;
 659         rs->rs_antenna = MS(ads.ds_rxstatus3, AR_RxAntenna);
 660         rs->rs_flags =
 661                 (ads.ds_rxstatus3 & AR_GI) ? ATH9K_RX_GI : 0;
 662         rs->rs_flags |=
 663                 (ads.ds_rxstatus3 & AR_2040) ? ATH9K_RX_2040 : 0;
 664
 665         if (ads.ds_rxstatus8 & AR_PreDelimCRCErr)
 666                 rs->rs_flags |= ATH9K_RX_DELIM_CRC_PRE;
 667         if (ads.ds_rxstatus8 & AR_PostDelimCRCErr)
 668                 rs->rs_flags |= ATH9K_RX_DELIM_CRC_POST;
 669         if (ads.ds_rxstatus8 & AR_DecryptBusyErr)
 670                 rs->rs_flags |= ATH9K_RX_DECRYPT_BUSY;
 671
 672         if ((ads.ds_rxstatus8 & AR_RxFrameOK) == 0) {
 673                 if (ads.ds_rxstatus8 & AR_CRCErr)
 674                         rs->rs_status |= ATH9K_RXERR_CRC;
 675                 else if (ads.ds_rxstatus8 & AR_PHYErr) {
 676                         rs->rs_status |= ATH9K_RXERR_PHY;
 677                         phyerr = MS(ads.ds_rxstatus8, AR_PHYErrCode);
 678                         rs->rs_phyerr = phyerr;
 679                 } else if (ads.ds_rxstatus8 & AR_DecryptCRCErr)
 680                         rs->rs_status |= ATH9K_RXERR_DECRYPT;
 681                 else if (ads.ds_rxstatus8 & AR_MichaelErr)
 682                         rs->rs_status |= ATH9K_RXERR_MIC;
 683         }
 684
 685         return 0;
 686 }
 687 EXPORT_SYMBOL(ath9k_hw_rxprocdesc);
 688
 689 /*
 690  * This can stop or re-enables RX.
 691  *
 692  * If bool is set this will kill any frame which is currently being
 693  * transferred between the MAC and baseband and also prevent any new
 694  * frames from getting started.
 695  */
 696 bool ath9k_hw_setrxabort(struct ath_hw *ah, bool set)
 697 {
 698         u32 reg;
 699
 700         if (set) {
 701                 REG_SET_BIT(ah, AR_DIAG_SW,
 702                             (AR_DIAG_RX_DIS | AR_DIAG_RX_ABORT));
 703
 704                 if (!ath9k_hw_wait(ah, AR_OBS_BUS_1, AR_OBS_BUS_1_RX_STATE,
 705                                    0, AH_WAIT_TIMEOUT)) {
 706                         REG_CLR_BIT(ah, AR_DIAG_SW,
 707                                     (AR_DIAG_RX_DIS |
 708                                      AR_DIAG_RX_ABORT));
 709
 710                         reg = REG_READ(ah, AR_OBS_BUS_1);
 711                         ath_print(ath9k_hw_common(ah), ATH_DBG_FATAL,
 712                                   "RX failed to go idle in 10 ms RXSM=0x%x\n",
 713                                   reg);
 714
 715                         return false;
 716                 }
 717         } else {
 718                 REG_CLR_BIT(ah, AR_DIAG_SW,
 719                             (AR_DIAG_RX_DIS | AR_DIAG_RX_ABORT));
 720         }
 721
 722         return true;
 723 }
 724 EXPORT_SYMBOL(ath9k_hw_setrxabort);
 725
 726 void ath9k_hw_putrxbuf(struct ath_hw *ah, u32 rxdp)
 727 {
 728         REG_WRITE(ah, AR_RXDP, rxdp);
 729 }
 730 EXPORT_SYMBOL(ath9k_hw_putrxbuf);
 731
 732 void ath9k_hw_startpcureceive(struct ath_hw *ah)
 733 {
 734         ath9k_enable_mib_counters(ah);
 735
 736         ath9k_ani_reset(ah);
 737
 738         REG_CLR_BIT(ah, AR_DIAG_SW, (AR_DIAG_RX_DIS | AR_DIAG_RX_ABORT));
 739 }
 740 EXPORT_SYMBOL(ath9k_hw_startpcureceive);
 741
 742 void ath9k_hw_stoppcurecv(struct ath_hw *ah)
 743 {
 744         REG_SET_BIT(ah, AR_DIAG_SW, AR_DIAG_RX_DIS);
 745
 746         ath9k_hw_disable_mib_counters(ah);
 747 }
 748 EXPORT_SYMBOL(ath9k_hw_stoppcurecv);
 749
 750 bool ath9k_hw_stopdmarecv(struct ath_hw *ah)
 751 {
 752 #define AH_RX_STOP_DMA_TIMEOUT 10000   /* usec */
 753 #define AH_RX_TIME_QUANTUM     100     /* usec */
 754         struct ath_common *common = ath9k_hw_common(ah);
 755         int i;
 756
 757         REG_WRITE(ah, AR_CR, AR_CR_RXD);
 758
 759         /* Wait for rx enable bit to go low */
 760         for (i = AH_RX_STOP_DMA_TIMEOUT / AH_TIME_QUANTUM; i != 0; i--) {
 761                 if ((REG_READ(ah, AR_CR) & AR_CR_RXE) == 0)
 762                         break;
 763                 udelay(AH_TIME_QUANTUM);
 764         }
 765
 766         if (i == 0) {
 767                 ath_print(common, ATH_DBG_FATAL,
 768                           "DMA failed to stop in %d ms "
 769                           "AR_CR=0x%08x AR_DIAG_SW=0x%08x\n",
 770                           AH_RX_STOP_DMA_TIMEOUT / 1000,
 771                           REG_READ(ah, AR_CR),
 772                           REG_READ(ah, AR_DIAG_SW));
 773                 return false;
 774         } else {
 775                 return true;
 776         }
 777
 778 #undef AH_RX_TIME_QUANTUM
 779 #undef AH_RX_STOP_DMA_TIMEOUT
 780 }
 781 EXPORT_SYMBOL(ath9k_hw_stopdmarecv);
 782
 783 int ath9k_hw_beaconq_setup(struct ath_hw *ah)
 784 {
 785         struct ath9k_tx_queue_info qi;
 786
 787         memset(&qi, 0, sizeof(qi));
 788         qi.tqi_aifs = 1;
 789         qi.tqi_cwmin = 0;
 790         qi.tqi_cwmax = 0;
 791         /* NB: don't enable any interrupts */
 792         return ath9k_hw_setuptxqueue(ah, ATH9K_TX_QUEUE_BEACON, &qi);
 793 }
 794 EXPORT_SYMBOL(ath9k_hw_beaconq_setup);
 795
 796 bool ath9k_hw_intrpend(struct ath_hw *ah)
 797 {
 798         u32 host_isr;
 799
 800         if (AR_SREV_9100(ah))
 801                 return true;
 802
 803         host_isr = REG_READ(ah, AR_INTR_ASYNC_CAUSE);
 804         if ((host_isr & AR_INTR_MAC_IRQ) && (host_isr != AR_INTR_SPURIOUS))
 805                 return true;
 806
 807         host_isr = REG_READ(ah, AR_INTR_SYNC_CAUSE);
 808         if ((host_isr & AR_INTR_SYNC_DEFAULT)
 809             && (host_isr != AR_INTR_SPURIOUS))
 810                 return true;
 811
 812         return false;
 813 }
 814 EXPORT_SYMBOL(ath9k_hw_intrpend);
 815
 816 enum ath9k_int ath9k_hw_set_interrupts(struct ath_hw *ah,
 817                                               enum ath9k_int ints)
 818 {
 819         enum ath9k_int omask = ah->imask;
 820         u32 mask, mask2;
 821         struct ath9k_hw_capabilities *pCap = &ah->caps;
 822         struct ath_common *common = ath9k_hw_common(ah);
 823
 824         ath_print(common, ATH_DBG_INTERRUPT, "0x%x => 0x%x\n", omask, ints);
 825
 826         if (omask & ATH9K_INT_GLOBAL) {
 827                 ath_print(common, ATH_DBG_INTERRUPT, "disable IER\n");
 828                 REG_WRITE(ah, AR_IER, AR_IER_DISABLE);
 829                 (void) REG_READ(ah, AR_IER);
 830                 if (!AR_SREV_9100(ah)) {
 831                         REG_WRITE(ah, AR_INTR_ASYNC_ENABLE, 0);
 832                         (void) REG_READ(ah, AR_INTR_ASYNC_ENABLE);
 833
 834                         REG_WRITE(ah, AR_INTR_SYNC_ENABLE, 0);
 835                         (void) REG_READ(ah, AR_INTR_SYNC_ENABLE);
 836                 }
 837         }
 838
 839         /* TODO: global int Ref count */
 840         mask = ints & ATH9K_INT_COMMON;
 841         mask2 = 0;
 842
 843         if (ints & ATH9K_INT_TX) {
 844                 if (ah->config.tx_intr_mitigation)
 845                         mask |= AR_IMR_TXMINTR | AR_IMR_TXINTM;
 846                 if (ah->txok_interrupt_mask)
 847                         mask |= AR_IMR_TXOK;
 848                 if (ah->txdesc_interrupt_mask)
 849                         mask |= AR_IMR_TXDESC;
 850                 if (ah->txerr_interrupt_mask)
 851                         mask |= AR_IMR_TXERR;
 852                 if (ah->txeol_interrupt_mask)
 853                         mask |= AR_IMR_TXEOL;
 854         }
 855         if (ints & ATH9K_INT_RX) {
 856                 if (AR_SREV_9300_20_OR_LATER(ah)) {
 857                         mask |= AR_IMR_RXERR | AR_IMR_RXOK_HP;
 858                         if (ah->config.rx_intr_mitigation) {
 859                                 mask &= ~AR_IMR_RXOK_LP;
 860                                 mask |=  AR_IMR_RXMINTR | AR_IMR_RXINTM;
 861                         } else {
 862                                 mask |= AR_IMR_RXOK_LP;
 863                         }
 864                 } else {
 865                         if (ah->config.rx_intr_mitigation)
 866                                 mask |= AR_IMR_RXMINTR | AR_IMR_RXINTM;
 867                         else
 868                                 mask |= AR_IMR_RXOK | AR_IMR_RXDESC;
 869                 }
 870                 if (!(pCap->hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
 871                         mask |= AR_IMR_GENTMR;
 872         }
 873
 874         if (ints & (ATH9K_INT_BMISC)) {
 875                 mask |= AR_IMR_BCNMISC;
 876                 if (ints & ATH9K_INT_TIM)
 877                         mask2 |= AR_IMR_S2_TIM;
 878                 if (ints & ATH9K_INT_DTIM)
 879                         mask2 |= AR_IMR_S2_DTIM;
 880                 if (ints & ATH9K_INT_DTIMSYNC)
 881                         mask2 |= AR_IMR_S2_DTIMSYNC;
 882                 if (ints & ATH9K_INT_CABEND)
 883                         mask2 |= AR_IMR_S2_CABEND;
 884                 if (ints & ATH9K_INT_TSFOOR)
 885                         mask2 |= AR_IMR_S2_TSFOOR;
 886         }
 887
 888         if (ints & (ATH9K_INT_GTT | ATH9K_INT_CST)) {
 889                 mask |= AR_IMR_BCNMISC;
 890                 if (ints & ATH9K_INT_GTT)
 891                         mask2 |= AR_IMR_S2_GTT;
 892                 if (ints & ATH9K_INT_CST)
 893                         mask2 |= AR_IMR_S2_CST;
 894         }
 895
 896         ath_print(common, ATH_DBG_INTERRUPT, "new IMR 0x%x\n", mask);
 897         REG_WRITE(ah, AR_IMR, mask);
 898         ah->imrs2_reg &= ~(AR_IMR_S2_TIM | AR_IMR_S2_DTIM | AR_IMR_S2_DTIMSYNC |
 899                            AR_IMR_S2_CABEND | AR_IMR_S2_CABTO |
 900                            AR_IMR_S2_TSFOOR | AR_IMR_S2_GTT | AR_IMR_S2_CST);
 901         ah->imrs2_reg |= mask2;
 902         REG_WRITE(ah, AR_IMR_S2, ah->imrs2_reg);
 903
 904         if (!(pCap->hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
 905                 if (ints & ATH9K_INT_TIM_TIMER)
 906                         REG_SET_BIT(ah, AR_IMR_S5, AR_IMR_S5_TIM_TIMER);
 907                 else
 908                         REG_CLR_BIT(ah, AR_IMR_S5, AR_IMR_S5_TIM_TIMER);
 909         }
 910
 911         if (ints & ATH9K_INT_GLOBAL) {
 912                 ath_print(common, ATH_DBG_INTERRUPT, "enable IER\n");
 913                 REG_WRITE(ah, AR_IER, AR_IER_ENABLE);
 914                 if (!AR_SREV_9100(ah)) {
 915                         REG_WRITE(ah, AR_INTR_ASYNC_ENABLE,
 916                                   AR_INTR_MAC_IRQ);
 917                         REG_WRITE(ah, AR_INTR_ASYNC_MASK, AR_INTR_MAC_IRQ);
 918
 919
 920                         REG_WRITE(ah, AR_INTR_SYNC_ENABLE,
 921                                   AR_INTR_SYNC_DEFAULT);
 922                         REG_WRITE(ah, AR_INTR_SYNC_MASK,
 923                                   AR_INTR_SYNC_DEFAULT);
 924                 }
 925                 ath_print(common, ATH_DBG_INTERRUPT, "AR_IMR 0x%x IER 0x%x\n",
 926                           REG_READ(ah, AR_IMR), REG_READ(ah, AR_IER));
 927         }
 928
 929         return omask;
 930 }
 931 EXPORT_SYMBOL(ath9k_hw_set_interrupts);